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();
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
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
