Expressao com parêntese [Dúvida new]

Programação Java
#1

Bom dia, desenvolvi um código para calcular a: união, intercessão e subtração de conjuntos, porém me surgiu uma ideia de utilizar parêntese , formando assim uma expressão de conjuntos, facilitando varias coisas, ex: (AuB)n(CuD) ==> traduzindo: “A união com B, intercessão com C união com D”, ou seja iria resolver primeiro as união dentro dos parênteses e só em seguida resolveria a intercessão, porém não sei como começar essa lógica, já pensei em usar pilha, mas talvez não daria certo, já tentei usar string.char, string.contens, porém fica bem complexo, alguém poderia me ajudar ??? obrigado vlw…

#2

Você precisa é de uma pilha mesmo. Dê uma lida sobre notação polonesa inversa e resolução de operadores com precedência.
http://www.icmc.usp.br/~sce182/paplic.html
http://pt.wikibooks.org/wiki/Algoritmos_e_Estruturas_de_Dados/Pilhas

#3

[quote=ViniGodoy]Você precisa é de uma pilha mesmo. Dê uma lida sobre notação polonesa inversa e resolução de operadores com precedência.
http://www.icmc.usp.br/~sce182/paplic.html
http://pt.wikibooks.org/wiki/Algoritmos_e_Estruturas_de_Dados/Pilhas[/quote]

Obrigado pela dica ! vou pesquisar aqui …vlw

#4

Estou tentando utilizar o código abaixo, acontece que ele não ta calculando expressão do tipo (8+1)-(24), algumas ele faz de boa como: (((57)7*3)-2) , outra tb (8-6)*1… porém a que estou precisando ele não faz, alguém sabe me dizer o motivo ??? segue o código abaixo… vlw

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;
      }
   }
#5