Expressao matematica(com parenteses e operacoes)

[jhowEstrela]

helpppppp

import javax.swing.JOptionPane; 

public class Calculadora {
    
    private String equacao;

    public static void main(String[] args) {
       Calculadora calc = new Calculadora();  
       Parentheses_check check = new Parentheses_check();
       
       calc.setEquacao(JOptionPane.showInputDialog("Expressão Numerica:"));  
    
       if(check.parentheses_valid(calc.getEquacao())) {
           System.out.println("Resultado: " + calc.eval(calc.getEquacao()));   
       } else {
           System.out.println("A expressão "+ calc.getEquacao() + "não é válida!");
       }
    }
    
    
    public static int eval(String expr) {
        int resultado = 0;
        char charI = expr.charAt(0);                
        if(charI == '(') {
                int indiceChaveFinal = expr.lastIndexOf(")");
                if(indiceChaveFinal == expr.length()-1) {
                    resultado = eval(expr.substring(1, expr.length()-1));
                } else {
                    char operador = expr.charAt(indiceChaveFinal+1);

                    if(operador == '*'){
                        resultado = eval(expr.substring(1, indiceChaveFinal)) * eval(expr.substring(indiceChaveFinal + 2, expr.length()));
                    }
                    if(operador == '/'){
                        resultado = eval(expr.substring(1, indiceChaveFinal)) / eval(expr.substring(indiceChaveFinal + 2, expr.length()));
                    }
                    if(operador == '+'){
                       resultado = eval(expr.substring(1, indiceChaveFinal)) + eval(expr.substring(indiceChaveFinal + 2, expr.length()));
                    }
                    if(operador == '-'){
                        resultado = eval(expr.substring(1, indiceChaveFinal)) - eval(expr.substring(indiceChaveFinal + 2, expr.length()));
                    }                         
                }           
        } else {
                int indiceOperador = expr.indexOf("+");
                int indiceOperador1 = expr.indexOf("-");
                int indiceOperador2 = expr.indexOf("*");
                int indiceOperador3 = expr.indexOf("/");
                if(indiceOperador == -1 && indiceOperador1 == -1 && indiceOperador2 == -1 && indiceOperador3 == -1 ) {
                    resultado = Integer.parseInt(expr);
                } else {
                     if(indiceOperador2 != -1) {
                         resultado = eval(expr.substring(0, indiceOperador2)) * eval(expr.substring(indiceOperador2 + 1, expr.length()));
                   }
                     if(indiceOperador3 != -1) {
                         resultado = eval(expr.substring(0, indiceOperador3)) / eval(expr.substring(indiceOperador3 + 1, expr.length()));
                   }
                    if(indiceOperador != -1) {
                        resultado = eval(expr.substring(0, indiceOperador)) + eval(expr.substring(indiceOperador + 1, expr.length()));
                   }
                     if(indiceOperador1 != -1) {
                         resultado = eval(expr.substring(0, indiceOperador1)) - eval(expr.substring(indiceOperador1 + 1, expr.length()));
                   }
                }
                
        }
        return resultado;
   }

    public String getEquacao() {  
        return this.equacao;  
    }  
    public void setEquacao(String str) {  
        this.equacao = str; 
    }    
       
 }





import java.util.Stack;

public class Parentheses_check
   {

   public static boolean is_open_parenthesis( char c )
      {
      if ( c=='(' || c=='[' || c=='{' )
         return true;
      else
         return false;
      }

   public static boolean is_closed_parenthesis( char c )
      {
      if ( c==')' || c==']' || c=='}' )
         return true;
      else
         return false;
      }

   private static boolean parentheses_match( char open, char closed )
      {
      if ( open=='(' && closed==')' )
         return true;
      else if ( open=='[' && closed==']' )
         return true;
      else if ( open=='{' && closed=='}' )
         return true;
      else
         return false;
      }

   public static boolean parentheses_valid( String exp )
      {
      Stack       s = new Stack();
      int         i;
      char        current_char;
      Character   c;
      char        c1;
      boolean     ret=true;

      for ( i=0; i < exp.length(); i++ )
         {

         current_char=exp.charAt( i );

         if ( is_open_parenthesis( current_char ) )
            {
            c=new Character( current_char );
            s.push( c );
            }
         else if ( is_closed_parenthesis( current_char ) )
            {
            if ( s.isEmpty() )
               {
               ret=false;
               break;
               }
            else
               {
               c=(Character)s.pop();
               c1=c.charValue();
               if ( !parentheses_match( c1, current_char ) )
                  {
                  ret=false;
                  break;
                  }
               }
            }
         }

      if ( !s.isEmpty() )
         ret=false;

      return ret;
      }
   }

helpppppp este codigo não esta calculando todos os tipos de expressao, da um erro , para os tipos que ele não ta calculando... !!

import javax.swing.JOptionPane;

public class Calculadora {

private String equacao;

public static void main(String[] args) {
Calculadora calc = new Calculadora();
Parentheses_check check = new Parentheses_check();

calc.setEquacao(JOptionPane.showInputDialog("Expressão Numerica:"));

if(check.parentheses_valid(calc.getEquacao())) {
System.out.println("Resultado: " + calc.eval(calc.getEquacao()));
} else {
System.out.println("A expressão "+ calc.getEquacao() + "não é válida!");
}
}


public static int eval(String expr) {
int resultado = 0;
char charI = expr.charAt(0);
if(charI == '(') {
int indiceChaveFinal = expr.lastIndexOf(")");
if(indiceChaveFinal == expr.length()-1) {
resultado = eval(expr.substring(1, expr.length()-1));
} else {
char operador = expr.charAt(indiceChaveFinal+1);

if(operador == '*'){
resultado = eval(expr.substring(1, indiceChaveFinal)) * eval(expr.substring(indiceChaveFinal + 2, expr.length()));
}
if(operador == '/'){
resultado = eval(expr.substring(1, indiceChaveFinal)) / eval(expr.substring(indiceChaveFinal + 2, expr.length()));
}
if(operador == '+'){
resultado = eval(expr.substring(1, indiceChaveFinal)) + eval(expr.substring(indiceChaveFinal + 2, expr.length()));
}
if(operador == '-'){
resultado = eval(expr.substring(1, indiceChaveFinal)) - eval(expr.substring(indiceChaveFinal + 2, expr.length()));
}
}
} else {
int indiceOperador = expr.indexOf("+");
int indiceOperador1 = expr.indexOf("-");
int indiceOperador2 = expr.indexOf("*");
int indiceOperador3 = expr.indexOf("/");
if(indiceOperador == -1 && indiceOperador1 == -1 && indiceOperador2 == -1 && indiceOperador3 == -1 ) {
resultado = Integer.parseInt(expr);
} else {
if(indiceOperador2 != -1) {
resultado = eval(expr.substring(0, indiceOperador2)) * eval(expr.substring(indiceOperador2 + 1, expr.length()));
}
if(indiceOperador3 != -1) {
resultado = eval(expr.substring(0, indiceOperador3)) / eval(expr.substring(indiceOperador3 + 1, expr.length()));
}
if(indiceOperador != -1) {
resultado = eval(expr.substring(0, indiceOperador)) + eval(expr.substring(indiceOperador + 1, expr.length()));
}
if(indiceOperador1 != -1) {
resultado = eval(expr.substring(0, indiceOperador1)) - eval(expr.substring(indiceOperador1 + 1, expr.length()));
}
}

}
return resultado;
}

public String getEquacao() {
return this.equacao;
}
public void setEquacao(String str) {
this.equacao = str;
}

}





import java.util.Stack;

public class Parentheses_check
{

public static boolean is_open_parenthesis( char c )
{
if ( c=='(' || c=='[' || c=='{' )
return true;
else
return false;
}

public static boolean is_closed_parenthesis( char c )
{
if ( c==')' || c==']' || c=='}' )
return true;
else
return false;
}

private static boolean parentheses_match( char open, char closed )
{
if ( open=='(' && closed==')' )
return true;
else if ( open=='[' && closed==']' )
return true;
else if ( open=='{' && closed=='}' )
return true;
else
return false;
}

public static boolean parentheses_valid( String exp )
{
Stack s = new Stack();
int i;
char current_char;
Character c;
char c1;
boolean ret=true;

for ( i=0; i < exp.length(); i++ )
{

current_char=exp.charAt( i );

if ( is_open_parenthesis( current_char ) )
{
c=new Character( current_char );
s.push( c );
}
else if ( is_closed_parenthesis( current_char ) )
{
if ( s.isEmpty() )
{
ret=false;
break;
}
else
{
c=(Character)s.pop();
c1=c.charValue();
if ( !parentheses_match( c1, current_char ) )
{
ret=false;
break;
}
}
}
}

if ( !s.isEmpty() )
ret=false;

return ret;
}
}

Editado Setembro 25, 2010 por quintelab
Adicionado BBCode Code