[RESOLVIDO] Duvida com o codigo fonte

Duvida 1) Como devo fazer?

Estou precisando pegar o valor do topo de uma pilha criada por locação dinamica, ouseja, por referência e verificar se nesta posição existe um caracter X.

Meu codigo:

   import javax.swing.*;
   import java.io.*;
  
    class TPPilha{
   
      private int tam;//variavel para controlar o tamanho da pilha
      private Celula topo;
      
       private static class Celula{
         String n;
         Celula prox;
         
      	/**
      	 * Construtor da classe celula
      	 */
          public Celula(String v,Celula prox)
         {
            n = v;
            this.prox = prox;
         }
      }
      
     /** 
      * Construtor da classe TP01_Pilha	
   	*/
       public TPPilha()
      {
         topo = null;//inicializando a pilha
      }
     
     /**
      * Metodo para verificar se a pilha esta vazia 
   	*/
       public boolean estaVazia()
      {
         return(topo == null);
      }
     
     /**
      * Metodo para desempilhar um elemento
   	*/
       public String pop(){
         if(this.estaVazia())
            throw new RuntimeException("");
      
         String v = topo.n;
         topo = topo.prox;
         tam--;
         return v;
      }
     
     /**
      * Metodo para empilhar um elemento
   	*/ 
       public void push(String v)
      {
         topo = new Celula(v,topo);
         tam++;
      }
     
     /**
      * Metodo para retornar o tamanho da Pilha
   	*/ 
       public int tamanho()
      {
         int t=0;
         Celula c = this.topo;
         Celula prox;
        //percorre a pilha e conta o numero de posições ocupadas
         while(c!=null)
         {
            c = c.prox;
            t++;
         }
      
         return t;
      }
     
     /**
      * Metodo para mostrar a pilha
   	*/ 
       public void mostrar()
      {
         TPPilha aux = new TPPilha();
      
         while(!this.estaVazia())
         {
            String a=this.pop();
            aux.push(a);
         }
      
         while(!aux.estaVazia())
         {
            String e = aux.pop();
            System.out.print(" "+e);
            this.push(e);
         }
      
      }
      
    /**
   	* Metodo para consultar se existe um caracter matematico com maior prioridade que outro
   	* A consulta é feita na pilha inteira.
   	*/
       public boolean consultar(String caracter)
      {
         boolean b=false;
         String verdade="";
         TPPilha consultar = new TPPilha();
         consultar.copia();//faz uma copia da pilha original
         consultar.mostrar();
         verdade = consultar.pop();//olha posiçao por posiçao a pilha toda, porem esta pilha não é mais aproveitada
         
         if(verdade.equals(caracter))
            b=true;
         
         return b;
      }
      
     /**
      * Metodo que copia uma pilha
   	*/ 
       public TPPilha copia(){
       
         TPPilha copia = new TPPilha();
         TPPilha aux = new TPPilha();
      
         while(!this.estaVazia()){
            String x = this.pop();
            copia.push(x);
         }
         
         while(!copia.estaVazia()){
            String valor = copia.pop();
            this.push(valor);
            aux.push(valor);
         }
      
         return aux;//retorna os valores da pilha copiada
      } 

Olhem se deste modo esta correto?

TPPilha = new TPPilha();

if( P.charAt(P.tamanho() == "*" )
S.O.P(" Deu certo!!! ");

ou pode ser assim?


if( P.topo.equals("/"))
S.O.P(" Deu certo!!! ");

O erro que ocorre é que ele não reconhece o charAt();

Obrigado quem puder me ajudar!!!

coloca a exception q ta gerando :smiley:

O erro é:
I:\1º trabalho de aed2\TPPilha.java:193: cannot resolve symbol
symbol : method charAt (int)
location: class TPPilha
if(P.charAt(P.tam)==’*’ || P.topo.equals("/") )
^
1 error

Não existe o metodo charAt(int index) na classe TPPilha esse metodo é da classe String onde vc pode quebrar a String em caracteres …

ok. entendi.
Agora para que eu acesse o topo dapilha eu posso fazer deste jeito?

Pilha.topo;

e para comparar o resultado
String str= “±+*-**+/”

pilha.topo == str.charAt(0);
ou
pilha.topo.equals(str.charAt(0));

Se for pra usar charAt(0), vc pode converter a sua string em um array de char com o método toCharArray() da classe String.

OK. vou tentar aqui.acabando eu posto o codigo para verem como ficou.

Vlw para todos que deram dicas e me ajudaram.

Como prometi, aqui esta o programa, porem eu fiz algumas modificações.
A classe pilha ela esta na internet para todos.

   import javax.swing.*;
   import java.io.*;

    class TestePilha{
    
     /**
      * Metodo Principal - Metodo de execuçao do programa
   	*/
       public static void main(String args[])throws Exception
      {
       //*************************************  Instrução ************************************
         			 
         JOptionPane.showMessageDialog(null," Este trabalho consiste em receber uma expressao matematica e fazer uma conversão."+
                                            "\n Esta conversão pode ocorrer de duas maneiras."+
            										  "\n 1ª) De Infixada para Pós-Fixada"+
            										  "\n 2ª) De Pós-Fixada para Infixada "," Trabalho Prático sobre Pilha ",JOptionPane.INFORMATION_MESSAGE);         
         
       //**************************** Declaraçao de variaveis ********************************
         Pilha P,A,L;//Pilha Principal, Auxiliar, Lixo
         Object exp_mat_rec;//Esta sendo usado object para que se possa usar uma variedade de dados maior, isso se precisar.
         int op;//variavel de controle na execução do menu
         String fim;//Variavel controle da expressão matemática.
         String exp_mat_pro;//Variavel "resposta" da expressão matematica.
         char caracter;//Variavel posição dentro da expressao matematica
         String convertida;//Variavel mudança de Tipo 
         String decisao;//Variavel controle da repetição do programa
         Object desconvertida;//Variavel mudança de tipo
         boolean parenteses;//Variavel controle de parenteses
      
       //**************************** Inicialização de variaveis ****************************
         decisao = "S";
         fim = "#";
         P  = new Pilha();//principal
         A  = new Pilha();//auxiliar
         L  = new Pilha();//lixo
         exp_mat_pro = "";
         parenteses = false;
      
       //**************************** Executando o Programa ********************************
       //Este while controla a repetiçao do programa, ou seja,caso queira repetir a execuçao ele entra em ação
         while(decisao.equals("S") || decisao.equals("s")){
           //entrada da expressão matematica
            exp_mat_rec = JOptionPane.showInputDialog(null," Digite a expressão matemática."," Expressão Matemática ",JOptionPane.QUESTION_MESSAGE);
           //entrada da opçao de execuçao
            op = Integer.parseInt(JOptionPane.showInputDialog(null," Escolha uma opção! \n "+
                                                           "(0) Finaliza o Programa. \n "+
               														  "(1) Conversão de infixada para pós-fixada \n "+
               														  "(2) Conversão de pós-fixada para infixada \n "," Opções para excutar o Programa ",JOptionPane.QUESTION_MESSAGE));
            convertida = ""+exp_mat_rec;//Recebe a expressão do tipo Object e a coloca como String
            convertida = convertida + fim;//Recebe a expressão  mudada e coloca no final dela o caracter controle
           
           //A variavel "op" é usada para controlar o menu do programa, ous eja, é ela que diz qual caminho o programa deve executar    															  
            switch(op){
            
            //finaliza o programa
               case 0:
                  {
                     System.exit(0);//finaliza o programa
                     break;
                  }//fim case 0
               //expressão infixada para pós-fixada
               case 1:
                  { //O for ira percorrer a expressão ate o final
                     for(int i=0; i<convertida.length(); i++){
                        caracter = convertida.charAt(i);//recebe caracter por caracter.
                       //O switch seleciona qual caracter ira ser executado.
                        switch(caracter){
                          //É executado quando o caracter selecionado é um #.
                          //Ao ser executado quer dizer que a expressão mnatematica acabou de ser lida totalmente
                           case '#': 
                              {
                              //desempilha a pilha auxiliar (é usado em caso de parenteses)
                                 while(!A.vazia())
                                    exp_mat_pro = exp_mat_pro + A.desempilha();//guarda na String o resultado 
                              //desempilha a pilha principal (é usado quando o programa acaba)
                                 while(!P.vazia())
                                    exp_mat_pro = exp_mat_pro + P.desempilha();
                              //mostra a expressão recebida e a produzida
                                 JOptionPane.showMessageDialog(null," A String recebida é:   "+exp_mat_rec+"\n A String produzida é:   "+exp_mat_pro," Resulatdo Final do Programa ",JOptionPane.INFORMATION_MESSAGE);
                              }//fim case #
                              break;
                          //É executado quando o caracter selecionado é um +.
                           case '+':
                              {//é ativado quando as variaveis estao dentro de parenteses
                                 if(P.vazia()&& !L.vazia()) A.empilha(""+caracter);
                                 else
                                 //neste caso é ativado normalmente. Serão empilhados na pilha principal, se ela estiver vazia
                                    if(P.vazia() && L.vazia())P.empilha(""+caracter);
                                    else{
                                    //senao começam as comparações
                                       String guarda = ""+P.desempilha();
                                       P.empilha(guarda);
                                       //comparaçao feita para prevenir prioridade
                                       if((guarda.equals("!")||guarda.equals("*")||guarda.equals("/"))&&(parenteses==false)){
                                          while(!P.vazia())
                                             exp_mat_pro = exp_mat_pro + P.desempilha();
                                          P.empilha(""+caracter);
                                       }//fim if((guarda.equals("!")||guarda.equals("*")||guarda.equals("/"))&&(parenteses==false))
                                       else{
                                          if((!guarda.equals("!"))&&(parenteses==false)){
                                             P.empilha(""+caracter);
                                          }//fim if((!guarda.equals("!"))&&(parenteses==false))
                                          else{
                                          //empilha na auxiliar
                                             if(A.vazia()) A.empilha(""+caracter);
                                             else{
                                                String compara = ""+A.desempilha();
                                                A.empilha(compara);
                                             //previni a prioridade dos caracteres
                                                if(compara.equals("*")||compara.equals("/")||compara.equals("!")){
                                                   exp_mat_pro = exp_mat_pro + A.desempilha();
                                                }
                                                A.empilha(""+caracter);
                                             }//fim else
                                          }
                                       }
                                    }//fim else
                              }//fim case +
                              break;
                          //É executado quando o caracter selecionado é um -.
                           case '-': 
                              {//é ativado quando as variaveis estao dentro de parenteses
                                 if(P.vazia()&& !L.vazia()) A.empilha(""+caracter);
                                 else
                                 //neste caso é ativado normalmente. Serão empilhados na pilha principal, se ela estiver vazia
                                    if(P.vazia() && L.vazia())P.empilha(""+caracter);
                                    else{
                                    //senao começam as comparações
                                       String guarda = ""+P.desempilha();
                                       P.empilha(guarda);
                                       //comparaçao feita para prevenir prioridade
                                       if((guarda.equals("!")||guarda.equals("*")||guarda.equals("/"))&&(parenteses==false)){
                                          while(!P.vazia())
                                             exp_mat_pro = exp_mat_pro + P.desempilha();
                                          P.empilha(""+caracter);
                                       }//fim if((guarda.equals("!")||guarda.equals("*")||guarda.equals("/"))&&(parenteses==false))
                                       else{
                                          if((!guarda.equals("!"))&&(parenteses==false)){
                                             P.empilha(""+caracter);
                                          }//fim if((!guarda.equals("!"))&&(parenteses==false))
                                          else{
                                          //empilha na auxiliar
                                             if(A.vazia()) A.empilha(""+caracter);
                                             else{
                                                String compara = ""+A.desempilha();
                                                A.empilha(compara);
                                             //previni a prioridade dos caracteres
                                                if(compara.equals("*")||compara.equals("/")||compara.equals("!")){
                                                   exp_mat_pro = exp_mat_pro + A.desempilha();
                                                }
                                                A.empilha(""+caracter);
                                             }//fim else
                                          }
                                       }
                                    }//fim else
                              }//fim case -
                              break;
                          //É executado quando o caracter selecionado é um *.
                           case '*':
                              {//é ativado quando as variaveis estao dentro de parenteses
                                 if(P.vazia()&& !L.vazia()) A.empilha(""+caracter);
                                 else
                                 //neste caso é ativado normalmente. Serão empilhados na pilha principal, se ela estiver vazia
                                    if(P.vazia() && L.vazia())P.empilha(""+caracter);
                                    else{
                                    //senao começam as comparações
                                       String guarda = ""+P.desempilha();
                                       P.empilha(guarda);
                                       //comparaçao feita para prevenir prioridade
                                       if((guarda.equals("!"))&&(parenteses==false)){
                                          exp_mat_pro = exp_mat_pro + P.desempilha();
                                          P.empilha(""+caracter);
                                       }//fim if(guarda.equals("!"))&&(parenteses==false))
                                       else{
                                          if((!guarda.equals("!"))&&(parenteses==false)){
                                             P.empilha(""+caracter);
                                          }//fim if((!guarda.equals("!"))&&(parenteses==false))
                                          else{
                                          //empilha na auxiliar
                                             if(A.vazia()) A.empilha(""+caracter);
                                             else{
                                                String compara = ""+A.desempilha();
                                                A.empilha(compara);
                                             //previni a prioridade dos caracteres
                                                if(compara.equals("*")||compara.equals("/")||compara.equals("!")){
                                                   exp_mat_pro = exp_mat_pro + A.desempilha();
                                                }
                                                A.empilha(""+caracter);
                                             }//fim else
                                          }
                                       }
                                    }//fim else
                              }//fim case *
                              break;
                          //É executado quando o caracter selecionado é um /.
                           case '/': 
                              {//é ativado quando as variaveis estao dentro de parenteses
                                 if(P.vazia()&& !L.vazia()) A.empilha(""+caracter);
                                 else
                                 //neste caso é ativado normalmente. Serão empilhados na pilha principal, se ela estiver vazia
                                    if(P.vazia() && L.vazia())P.empilha(""+caracter);
                                    //senao começam as comparações
                                    else{
                                       String guarda = ""+P.desempilha();
                                       P.empilha(guarda);
                                       //comparaçao feita para prevenir prioridade
                                       if((guarda.equals("!"))&&(parenteses==false)){
                                          exp_mat_pro = exp_mat_pro + P.desempilha();
                                          P.empilha(""+caracter);
                                       }//fim if(guarda.equals("!"))&&(parenteses==false))
                                       else{
                                          if((!guarda.equals("!"))&&(parenteses==false)){
                                             P.empilha(""+caracter);
                                          }//fim if((!guarda.equals("!"))&&(parenteses==false))
                                          else{
                                          //empilha na auxiliar
                                             if(A.vazia()) A.empilha(""+caracter);
                                             else{
                                                String compara = ""+A.desempilha();
                                                A.empilha(compara);
                                             //previni a prioridade dos caracteres
                                                if(compara.equals("*")||compara.equals("/")||compara.equals("!")){
                                                   exp_mat_pro = exp_mat_pro + A.desempilha();
                                                }
                                                A.empilha(""+caracter);
                                             }//fim else
                                          }
                                       }
                                    }//fim else
                              }//fim case /
                              break;
                          //É executado quando o caracter selecionado é um (.
                           case '(': 
                              {
                              //empilha na pilha lixo o parenteses e muda a variavel controle de parenteses para true
                                 L.empilha(""+caracter);
                                 parenteses = true;//conmtrole de parenteses
                              }//fim case (
                              break;
                          //É executado quando o caracter selecionado é um ).
                           case ')': 
                              {
                              //esvazia a pilha auxiliar toda, pois os parenteses chegaram ao fim
                                 while(!A.vazia())
                                    exp_mat_pro = exp_mat_pro + A.desempilha();
                              //desempilha da pilha principal para continuar na execuçao correta
                                 while(!P.vazia())
                                    exp_mat_pro = exp_mat_pro + P.desempilha();
                              //desempilha do lixo para manter sempre esta pilha vazia para que possa ser usada novamente sem erros no programa
                                 while(!L.vazia())
                                    L.desempilha();
                                 parenteses = false;//muda a variavel para false mostrando que o parenteses ja acabou
                              }//fim case )
                              break;
                          //É executado quando o caracter selecionado é um !.
                           case '!': 
                              {//é ativado quando as variaveis estao dentro de parenteses
                                 if(P.vazia()&& !L.vazia()) A.empilha(""+caracter);
                                 else
                                 //neste caso é ativado normalmente. Serão empilhados na pilha principal, se ela estiver vazia
                                    if(P.vazia() && L.vazia())P.empilha(""+caracter);
                                    //senão começam as comparaçoes
                                    else{
                                       String guarda = ""+P.desempilha();
                                       P.empilha(guarda);
                                       //comparaçao feita para prevenir prioridade
                                       if((guarda.equals("!"))&&(parenteses==false)){
                                          exp_mat_pro = exp_mat_pro + P.desempilha();
                                          P.empilha(""+caracter);
                                       }//fim if(guarda.equals("!"))&&(parenteses==false))
                                       else{
                                          if((!guarda.equals("!"))&&(parenteses==false)){
                                             P.empilha(""+caracter);
                                          }//fim if((!guarda.equals("!"))&&(parenteses==false))
                                          else{
                                             A.empilha(""+caracter);   
                                          }//fim else
                                       }
                                    }
                              }//fim case !
                              break;
                          //É executado quando for letra, ou seja, quando nao for os sinais.
                           default:
                              {
                                 exp_mat_pro = exp_mat_pro +""+ caracter;//concatena os caracteres à String
                              }//fim default
                        }//fim switch(caracter)
                     }//fim for
                  };//fim case 1
                  break;
            //expressão pós-fixada --> infixada
               case 2: 
                  {
                     String especialA = "(";//caracter criado para auxiliar no controle e validaçao das expressoes
                     String especialB = ")";//caracter criado para auxiliar no controle e validaçao das expressoes
                     String first;//guarda o 1º caracter da pilha
                     String second;//guarda o 2º caracter da pilha
                     String parte;//guarda as concatenações dos desempilhamentos
                   //O for ira percorrer a expressão ate o final
                     for(int i=0; i<convertida.length(); i++){
                        caracter = convertida.charAt(i);//recebe caracter por caracter.
                       //O switch seleciona qual caracter ira ser executado.
                        switch(caracter){
                          //É executado quando o caracter seleciona é um
                           case '#': 
                              {
                                 exp_mat_pro = exp_mat_pro + P.desempilha();//concatena na string  o conteudo da pilha principal
                                //mostra na tela
                                 JOptionPane.showMessageDialog(null," A String recebida é:   "+exp_mat_rec+"\n A String produzida é:   "+exp_mat_pro," Resulatdo Final do Programa ",JOptionPane.INFORMATION_MESSAGE);
                              }//fim case #
                              break;
                           //É executado quando o caracter seleciona é um +
                           case '+':
                              {
                                 first = ""+P.desempilha();//guarda a 1ª
                                 second = ""+P.desempilha();//guarda a 2ª
                                 parte =  especialA + second + caracter + first + especialB;//guarda a concatenaçao
                                 P.empilha(parte);//empilha a concatenaçao
                              }//fim case +
                              break;
                           //É executado quando o caracter seleciona é um -
                           case '-': 
                              {
                                 first = ""+P.desempilha();//guarda a 1ª
                                 second = ""+P.desempilha();//guarda a 2ª
                                 parte =  especialA + second + caracter + first + especialB;//guarda a concatenaçao
                                 P.empilha(parte);//empilha a concatenaçao
                              }//fim case -
                              break;
                          //É executado quando o caracter seleciona é um *
                           case '*':
                              {
                                 first = ""+P.desempilha();//guarda a 1ª
                                 second = ""+P.desempilha();//guarda a 2ª
                                 parte =  especialA + second + caracter + first + especialB;//guarda a concatenaçao
                                 P.empilha(parte);//empilha a concatenaçao
                              }//fim case *
                              break;
                          //É executado quando o caracter seleciona é uma /
                           case '/': 
                              {
                                 first = ""+P.desempilha();//guarda a 1ª
                                 second = ""+P.desempilha();//guarda a 2ª
                                 parte =  especialA + second + caracter + first + especialB;//guarda a concatenaçao
                                 P.empilha(parte);//empilha a concatenaçao
                              }//fim case /
                              break;
                          //É executado quando o caracter seleciona é um !
                           case '!': 
                              {
                                 first = ""+P.desempilha();//guarda a 1ª
                                 second = ""+P.desempilha();//guarda a 2ª
                                 //agora acontece diferente.
                              	//faz uma concatenaçao diferente. Sinal mais variavel
                                 parte =  especialA + first + caracter + especialB;
                                 P.empilha(second);//empilha a segunda variavel 
                                 P.empilha(parte);//empilha a concatenaçao, porem do sinal com a variavel
                              }//fim case !
                              break;
                           //É executado quando o caracter seleciona é uma letra
                           default:
                              {
                                 P.empilha(""+caracter);//empilha o caracter transformado para String
                              }//fim default
                        }//fim switch caracter
                     }//fim for
                  };//fim case 2
                  break;
            //condiçao executada, caso o usuario digite um numero errado na opçao de execução 
               default:
                  {
                    //O while entra em ação quando o usuario digita um valor invalido na execuçao do menu
                    //  e fica repetindo enquanto o valor for falso
                     while(op!=0 && op!=1 && op!=2){
                        op = Integer.parseInt(JOptionPane.showInputDialog(null," \n Escolha outra opção! Esta é invalida! \n "+
                                                                       "(0) Finaliza o Programa. \n "+
                           										              "(1) Conversão de infixada para pós-fixada \n "+
                           										              "(2) Conversão de pós-fixada para infixada \n "," ERRO ENCONTRADO !!! ",JOptionPane.QUESTION_MESSAGE));
                     
                     }//fim while
                  }//fim default
            }//fim switch(op)
            
         	//"Zerando" variavel por segurança
            exp_mat_pro = "";
            //condiçao para repetir a execuçao do programa
            decisao = JOptionPane.showInputDialog(" Continuar, digite (S)\n");
         }//fim while(decisao.equals("S") || decisao.equals("s"))	
      }//fim main
   }//fim class