Discussion :

[dahouo]

Bonjour à tous on s'est amusé en cours à ecrire petit code en java pour une calculatrice.
le but est de pouvoir faire un calcul en tenant compte des priorités c'est à dire pour moi des signes. Pour cela j'ai donc utilisé un stringTokenizer pour delimiter le calcul et récupérer les différents membres de l'opération. Seulement on a réussi avec uniquement 02 membres.
Je voudrais avoir des pistes pour étendre le code à une suites de plusieurs membres sans limites.
Merci
Voici mon code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
import java.io.IOException;
import java.rmi.ServerException;
import java.util.StringTokenizer;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
/**
 *
 * @author Arnaud *****
 */
public class Calculatrice extends HttpServlet
{
    @Override
    public void doGet (HttpServletRequest request, HttpServletResponse response)
            throws IOException, ServletException
{
            this.getServletContext().getRequestDispatcher("/WEB-INF/calculatrice.jsp")
                    .forward(request, response);
}
    @Override
    public void doPost (HttpServletRequest request, HttpServletResponse response)
            throws IOException, ServletException
{
        String valeurs = request.getParameter("valeurs");
        StringTokenizer stMul = new StringTokenizer(valeurs,"*");
        StringTokenizer stAdd = new StringTokenizer(valeurs,"+");
        StringTokenizer stSou = new StringTokenizer(valeurs,"-");
        StringTokenizer stDiv = new StringTokenizer(valeurs,"/");
        int resultat = 0;
 
 
        if(stMul.countTokens()==1){
            if (stAdd.countTokens()==1){
                if (stSou.countTokens()==1){
                    if (stDiv.countTokens()==1){
                        System.out.println("Error");
                  }
                    else {resultat= Integer.parseInt(stDiv.nextToken())/Integer.parseInt(stDiv.nextToken());}
              }
                 else {resultat= Integer.parseInt(stSou.nextToken())-Integer.parseInt(stSou.nextToken());}
            }
               else {resultat= Integer.parseInt(stAdd.nextToken())+Integer.parseInt(stAdd.nextToken());}
        }
           else{resultat= Integer.parseInt(stMul.nextToken())*Integer.parseInt(stMul.nextToken());}
 
         request.setAttribute("resultat", resultat);
 
        this.getServletContext().getRequestDispatcher("/WEB-INF/calculatrice.jsp")
             .forward(request, response);
 
}
}

[joel.drigo]

Salut,

Déjà, tu ne traites que 2 cas : un seul token trouvé, ou deux, alors que "5*3*5" donnera trois tokens, plus généralement, on aura un token ou plusieurs, qu'il faudrait traiter dans une boucle. Le fait de créer 4 StringTokenizers ne te permet pas de traiter facilement la présence de plusieurs signes : "5*3+5" te donnera soit deux tokens, soit un, quelque soit le StringTokenizer. Et ça fera planter le parseInt. En plus, si tu as une expression du type "5+", ou "5 5", non calculables, les tokens ne te permettront pas de le savoir, donc tu ne pourras pas le traiter.

Habituellement, on traite la problématique d'évaluation d'expressions par arbre, dont les nœuds sont soit un nombre, soit un signe (les parenthèses n'impactent que la façon de lier les nœuds, de même pour les notions de priorité). Il suffit ensuite de parcourir l'arbre en postfixé : ça revient à convertir l'expression en notation polonaise inversée. Personnellement, je préfère parser avec un automate à état, mais on peut le faire avec un StringTokenizer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
StringTokenizer s = new StringTokenizer(expression, "+-/*() ", true); // le true permet d'inclure les délimiteurs dans les tokens
while( s.hasMoreTokens() ) {
   String token = s.nextToken();
   if( !token.trim().isEmpty() ) { // on ignore les espaces
       if ( token.matches("\\d+") ) {
          // c'est un nombre
       }       
       else {
          // c'est un signe (ou une parenthèse)
       }
   }
}

A noter une petite difficulté sur la gestion des nombres négatifs, qui pourra se gérer avec un booléen.

Mais si tu ne connais pas les arbres, ou que tu ne dois pas utiliser d'arbre, on peut procéder différemment, par "boucle récursive". Simplifions d'abord : on ne traite ni séparateur ni parenthèses. Peut-être est-ce d'ailleurs une condition de ton énoncé.
Tu fais une méthode pour chaque signe, qui fait donc un StrintTokenizer( string, signe). Cette méthode retourne un résultat de calcul.

1. s'il n'y a qu'un token, alors tu appelles pour ce token (ou l'expression entière ça revient au même), la méthode traitant le signe de priorité immédiatement supérieure
2. s'il y a plusieurs tokens, tu fais une boucle (le même while que dans mon exemple ci-dessus), et pour chaque token, tu appelles la méthode. Tu combines les résultats retournés par le signe courant.
3. dans la méthode qui traite le signe de priorité la plus haute, tu ne peux plus appeler de méthode de signe de priorité supérieur : à la place, tu appelles une méthode qui transforme l'expression en nombre et retourne ce nombre en résultat.
4. le premier appel sur l'expression complète appelle la méthode de signe de priorité la moins importante

Pour traiter les espaces, il suffit d'inclure l'espace dans les délimiteurs, et d'utiliser le booléen true comme dans mon exemple. Ce qui te permet de tester s'il y a une espace dans l'un de tokens, et de le traiter. Les parenthèses sont un peu plus complexes à traiter : le plus simple serait de les traiter à part, dans une autre "boucle récursive", pour découper en sous-expressions qu'on traiterait avec la méthode décrite ci-avant.