Alguns problemas foram resolvidos aki no fórum, mas agora quando vou rodar o programa da um erro do qual não sei o que pode ser...
Preciso que alguem rode o programa e veja o que acontece, todas as classes e suas dependências estão em código.
O programa criado como entrada é o seguinte...
2 8 8 + +
( ( 8 * 2 ) + ( 7 + 9 ) )
( 9 + 3 + 4 * 2 / 12 - 3 )
Por favor se puderem me ajudar ficarei super agradecido, faz parte de um projeto que tenho que entregar na facul, mas encontrei alguns obstáculos...
obrigado.
import java.io.*;
import java.nio.*;
import java.util.*;
public class LeTokensArquivo {
public static void main(String[]args) {
//Abrindo arquivo
File arq = new File("F:\\Project-02\\entrada.txt");
File arq2 = new File("F:\\Project-02\\saida.txt");
String[] operadores = {"+", "-", "*", "/", "r", "e"};
PilhaS ps = new PilhaS(50);
Pilha p = new Pilha(50);
StringTokenizer st;
String temp = null, temp2, operador, valida, res;
Double resultado, op2, op1;
try {
//cria buffer de leitura
BufferedReader br = new BufferedReader(new FileReader(arq));
BufferedWriter bw = new BufferedWriter(new FileWriter(arq2));
String s;
//lê as linhas do arquivo e imprime-as na tela
s = br.readLine(); // Ler linha.
while(s != null) {
st = new StringTokenizer(s);
while(st.hasMoreTokens()) //Verifica se existe algum token que ainda não foi separado.
temp = (st.nextToken()); // "pega" o próximo token.
if(temp.equals("(")){
while(st.hasMoreTokens()){
temp = st.nextToken();
if(temp.equals(")")){
op1 = Double.valueOf(ps.desempilhar());
operador = ps.desempilhar();
op2 = Double.valueOf(ps.desempilhar());
temp2 = ps.desempilhar();
resultado = calculadora.infixa(ps, p);
PrintWriter saida = new PrintWriter(bw);
saida.println(resultado);
}
else{
ps.empilhar(temp);
}
}
}
else{
p.empilhar(Double.valueOf(temp));
while(st.hasMoreTokens()){
temp = (st.nextToken());
for(int i = 0; i < operadores.length; i++){
if(temp.equals(operadores[i])){
while(st.hasMoreTokens()){
ps.empilhar(temp);
temp = st.nextToken();
}
resultado = calculadora.posfixa(ps, p);
PrintWriter saida = new PrintWriter(bw);
saida.println(resultado);
}
else{
p.empilhar(Double.valueOf(temp));
}
}
}
}
s = br.readLine();
}
//fecha o buffer de leitura que também fecha o arquivo de leitura.
br.close();
bw.close();
}
catch(FileNotFoundException el) {
//caso o arquivo não exista
System.out.println("Arquivo não existe" + arq);
}
catch(IOException e2) {
//caso seja detectado algum outro erro de IO
e2.printStackTrace();
}
}
}
public class calculadora
{
public static Double posfixa(PilhaS ps, Pilha p)
{
PilhaS ps2 = new PilhaS(50);
Double op1, op2, resultado;
String op, temp;
while(!ps.pilhaVazia()){
temp = ps.desempilhar();
ps2.empilhar(temp);
}
op1 = p.desempilhar();
op = ps2.desempilhar();
if(op.equals("r")){
resultado = poperacao(op, op1, p);
}
else{
op2 = p.desempilhar();
resultado = poperacao(op, op1, op2, p);
}
do{
if(p.pilhaVazia()){
op = ps2.desempilhar();
op2 = p.desempilhar();
resultado = poperacao(op, resultado, op2, p);
}
else{
return resultado;
}
}while(
public static Double poperacao(String operador, Double op1, Pilha pilha){ //Converter os parametros para o objeto Double
return poperacao(operador, op1, null, p);
} //Pegar resultado e fazer a próxima operação.
public static Double poperacao(String operador, Double op1, Double op2, Pilha pilha)
{
Double exp = new Double(1), resultado = new Double(0);
double pot = 0;
String []op = {"+","-","*","/","p","r","0"};
for(int i = 0; i < op.length; i++)
{
if(operador.equals(op[i]))
{
switch(i)
{
case 0:
resultado = op1 + op2;
pilha.empilhar(resultado);
break;
case 1:
resultado = op1 - op2;
pilha.empilhar(resultado);
break;
case 2:
resultado = op1 * op2;
pilha.empilhar(resultado);
break;
case 3:
resultado = op1 / op2;
pilha.empilhar(resultado);
break;
case 4:
for(int j = 0; j < op2; j++){
pot = pot * op1;}
resultado = pot;
pilha.empilhar(resultado);
break;
case 5:
resultado = Math.sqrt(op1);
pilha.empilhar(resultado);
break;
}
}
}
return resultado;
}
// Usando "D"ouble pode-se receber um valor nulo.
/*public static Double operacao(String operador, Double op1){
return operacao(operador, op1, null); */
// usar .equals quando usar classe.
public static Double infixa()
{
Double op1;
String operador;
String sair;
Double op2;
op1 = EntradaDados.real("Digite o 1º operando");
do{
operador = EntradaDados.string("Digite o operador");
if(operador.equals("r"))
{
System.out.print(operacao(operador,op1));
}
op2 = EntradaDados.real("Digite o 2º operando");
do{
sair = EntradaDados.string("Deseja Sair(s/n)");
}while(!(sair.equals("n") || sair.equals("s")));
op1 = operacao(operador,op1,op2);
}while(sair.equals("n"));
return op1;
}
public static Double operacao(String operador, Double op1){
return operacao(operador, op1, null);
}
public static Double operacao(String operador, Double op1, Double op2)
{
Double exp = new Double(1), resultado = new Double(0);
String []op = { "+", "-", "*", "/", "e", "r"};
for(int i = 0; i < op.length; i++) // o int só é usado dentro do "for", quando sair do "for" o int será descartado.
{
if(operador.equals(op[i]))
{
switch(i)
{
case 0:
resultado = op1 + op2;
break;
case 1:
resultado = op1 - op2;
break;
case 2:
resultado = op1 * op2;
break;
case 3:
resultado = op1 / op2;
break;
case 4:
for(int j = 0; j < op2; j++)
{
exp = exp * op1;
}
resultado = exp;
break;
case 5:
resultado = Math.sqrt(op1);
break;
}
}
}
return resultado;
}
}
public class PilhaS
{
private String p[];
private int topo = -1;
public PilhaS(int tamanho)
{
p = new String[tamanho];
}
public boolean pilhaVazia()
{
if(topo == -1)
{
System.out.println("Pilha Vazia");
return true;
}
else
{
return false;
}
}
public boolean pilhaCheia()
{
if(topo == p.length - 1)
{
System.out.println("Pilha Cheia");
return true;
}
else
{
return false;
}
}
public boolean empilhar(String elemento)
{
if(!pilhaCheia())
{
topo++;
p[topo] = elemento;
return true;
}
else
{
return false;
}
}
public String desempilhar()
{
if(pilhaVazia())
{
System.out.println("Não há elementos para desempilhar");
return String.valueOf(-1);
}
else
{
return String.valueOf(p[topo--]);
}
}
public String mostrarTopo()
{
return String.valueOf(p[topo]);
}
public int tamanho()
{
return p.length;
}
}
public class Pilha
{
private double p[];
private int topo = -1;
public Pilha(int tamanho)
{
p = new double[tamanho];
}
public boolean pilhaVazia()
{
if(topo == -1)
{
System.out.println("Pilha Vazia");
return true;
}
else
{
return false;
}
}
public boolean pilhaCheia()
{
if(topo == p.length - 1)
{
System.out.println("Pilha Cheia");
return true;
}
else
{
return false;
}
}
public boolean empilhar(Double elemento)
{
if(!pilhaCheia())
{
topo++;
p[topo] = elemento;
return true;
}
else
{
return false;
}
}
public double desempilhar()
{
if(pilhaVazia())
{
System.out.println("Não há elementos para desempilhar");
return -1;
}
else
{
return p[topo--];
}
}
public double mostrarTopo()
{
return p[topo];
}
public int tamanho()
{
return p.length;
}
}
Agradecido Gerson
