Multiplicação usando Pilhas

public class TestaOperacao
{
  public static void main (String[] args)
  {
    int numero = 1234567;
    String num = Integer.toString(numero);

    char [] pilha = num.toCharArray();

    String valor = "";

    for (int i = 0; i < pilha.length; i++)
      valor = Double.toString(3 * pilha[i]);
  }
}

import java.awt.*;
import javax. swing.*;

public class teste {
    
    
    public teste() {
    }
    
            
    public static void main(String[] args) {
        String ResulTotal = "";
        String x = "";          //armazena o resultado total da conta
        String leng, leng1;     //recebe o valor de length de vT
        int y = 0;
        String num1 = "";
        String num2 = "";
        boolean status = false;
        char digit;
        char[]letra = new char[1];
        Pilha  pilha1, pilha2, pilha22, pilhaR1, pilhaR2, pilhaT1, pilhaT2, pilhaTotal;
        int indice, indice2, indice3;             //indice recebe o valor lenght do maior numero
        int carry = 0;                  //vai receber o valor de carry da multiplicação
        int v1, v2, vT = 0;             //irão receber os valores retirados da pilha, vT é o valor da multiplicação destes dois
        int compara, compara2 = 0;                
    
        try{
            
            while (status == false){
                num1 = JOptionPane.showInputDialog(null,"Digite o multiplicador.","Teste",JOptionPane.INFORMATION_MESSAGE); 
                if (num1.length() > 2 || num1.length() < 2){
                    JOptionPane.showMessageDialog(null,"Erro! \n O número deve conter dois digitos.\n De 00 à 99 ", "Erro!",JOptionPane.ERROR_MESSAGE);
                }
                else{
                    status = true;
                }
            }
            
            while (status == true){
                num2 = JOptionPane.showInputDialog(null,"Digite o multiplicando.","Teste",JOptionPane.INFORMATION_MESSAGE);
                if (num2.length() < 2){
                    JOptionPane.showMessageDialog(null,"Erro! \n O número deve conter no minimo dois digitos.", "Erro!",JOptionPane.ERROR_MESSAGE);
                }
                else {
                    status = false;
                }
            }
            
            if (num1.length() >= num2.length()) //definição do valor de "indice"
                indice = num1.length();
            else {
                indice = num2.length();
            }
            
            indice2 = indice + 2;
            indice3 = indice - 2;
            
            pilha1      = new Pilha(indice+1);    //pilha1, com tamanho "indice" vai conter o multiplicador
            pilha2      = new Pilha(indice+1);    //pilha2, ||   ||       ||     ||    ||  o nº a ser multiplicado
            pilha22     = new Pilha(indice+1);    //pilha2, ||   ||       ||     ||    ||  o nº a ser multiplicado
            pilhaR1     = new Pilha(indice2);//pilhaR1 vai receber o valor da multiplicação do primeiro elemento de pilha1
            pilhaR2     = new Pilha(indice2);//pilhaR2 vai receber o valor da multp. do segundo elemento de pilha1
            pilhaT1     = new Pilha(indice2);//pilhaT1 vai receber o valor de R1 invertido
            pilhaT2     = new Pilha(indice2);//pilhaT2 vai receber o valor de R2 invertido
            pilhaTotal  = new Pilha(indice2+1);//pilhaTotal vai receber o valor total da multiplicação
           
            
            for (int i = 0;i < num1.length(); i++){//passa os digitos do nº para a pilha
                    letra[0] = num1.charAt(i);
                    pilha1.push(new String(letra));
            }
            
           
            for (int i = 0;i < num2.length(); i++){//passa os digitos do nº para a pilha
                    letra[0] = num2.charAt(i);
                    pilha2.push(new String(letra));
                    pilha22.push(new String(letra));
            }
            
            compara = indice - num2.length();
            
            if (compara > 0){
                for (int i = 0; i < compara-1; i++){
                    pilha2.push("0");
                    pilha22.push("0");
                }                    
            }
            
            pilha1.pop(true);
            v1 = Integer.parseInt(pilha1.gettmp());
            for (int i = 0; i < indice; i++){ //gera o resultado da multp. do 1º digito de num1
                pilha2.pop(true);
                v2 = Integer.parseInt(pilha2.gettmp());
                
                vT = v1 * v2;
                vT = vT + carry;
                
                carry = 0;      //atribui 0 ao valor, para caso não gere um carry a multip., não somar o carry anterior
                leng = String.valueOf(vT);                
                if (i < indice2 && leng.length() > 1){ //"i < indice -1" para não gerar carry na ultima multip. ERRO!
                    carry = Integer.parseInt(String.valueOf(leng.charAt(0)));
                    vT = Integer.parseInt(String.valueOf(leng.charAt(1)));
                }
                
                pilhaR1.push(String.valueOf(vT));                
            }
            
            pilhaR1.push(String.valueOf(carry));
            carry = 0;
            
            pilhaT1.push(String.valueOf(y));
            
            for (int i = 0; i < indice+1; i++ ){ // passa os digitos de R1 para T1, para inverter a ordem
                pilhaR1.pop(true);
                pilhaT1.push(pilhaR1.gettmp());
            }
            
            
            
            pilha1.pop(true);
            v1 = Integer.parseInt(pilha1.gettmp());
            for (int i = 0; i < indice; i++){ //gera o resultado da multp. do 2º digito de num1
                pilha22.pop(true);
                v2 = Integer.parseInt(pilha22.gettmp());
                
                vT = v1 * v2;
                vT = vT + carry;
                
                carry = 0;      //atribui 0 ao valor, para caso não gere um carry a multip., não somar o carry anterior
                leng = String.valueOf(vT);                
                if (i < indice2 && leng.length() > 1){ //"i < indice" para não gerar carry na ultima multip. ERRO!
                   carry = Integer.parseInt(String.valueOf(leng.charAt(0)));
                   vT = Integer.parseInt(String.valueOf(leng.charAt(1)));
                }
                pilhaR2.push(String.valueOf(vT));                
            }
            
            pilhaR2.push(String.valueOf(carry));
            carry = 0;
                      
           indice2 = pilhaR2.getNEP();
           for (int i = 0; i < pilhaR2.getNEP(); i++ ){ //passa os digitos de R2 para T2, para inverter a ordem
                pilhaR2.pop(true);
                JOptionPane.showMessageDialog(null,"Passagem de R para Total "+ pilhaR2.gettmp(), "Resultado!",JOptionPane.INFORMATION_MESSAGE);
                pilhaT2.push(pilhaR2.gettmp());
            }
           
            
           compara = pilhaT1.getNEP();
           compara2 = pilhaT1.getTMP();
           compara = compara2 - compara; 
           if (compara > 0){
                for (int i = 0; i < compara; i++){
                    pilhaT1.push("0");
                }                    
            }
          
           compara = pilhaT2.getNEP();
           compara2 = pilhaT2.getTMP();
           compara = compara2 - compara; 
          if (compara > 0){
                for (int i = 0; i < compara; i++){
                    pilhaT2.push("0");
                }                    
            }
           
            indice2 = pilhaT2.getNEP();
            for (int i = 0; i < indice2; i++){ //gera o resultado da soma de T1[i] + T2[i]
                
                pilhaT2.pop(true);
                v2 = Integer.parseInt(pilhaT2.gettmp());
                
                pilhaT1.pop(true);
                v1 = Integer.parseInt(pilhaT1.gettmp());
                
                vT = v1 + v2;
                vT = vT + carry;
                
                carry = 0;      //atribui 0 ao valor, para caso não gere um carry a multip., não somar o carry anterior
                
                leng = String.valueOf(vT);                
                if (i < indice2 && leng.length() > 1){ //"i < indice" para não gerar carry na ultima multip. ERRO!
                   carry = Integer.parseInt(String.valueOf(leng.charAt(0)));
                   vT = Integer.parseInt(String.valueOf(leng.charAt(1)));
                }
                
                pilhaTotal.push(String.valueOf(vT));                
            }
           
           pilhaTotal.push(String.valueOf(carry));
           carry = 0;
           
           indice2 = pilhaTotal.getNEP();
           for (int i = 0; i < indice2; i++){
                pilhaTotal.pop(true);
                x = pilhaTotal.gettmp();
                ResulTotal = ResulTotal + x;
            }
           
            JOptionPane.showMessageDialog(null,"O resultado é: \n" + ResulTotal, "Resultado!",JOptionPane.INFORMATION_MESSAGE);
     }
            
         catch(PilhaException ex){
                        
                        JOptionPane.showMessageDialog(null,"Erro! \n O Programa será fechado.", "Erro!",JOptionPane.ERROR_MESSAGE);
                        System.exit(0);
                        
                  }
        System.exit(0);
    }
    
}