Quelle est la bonne préséance de l'expression mathématique

Quelle est la bonne séquence des opérations mathématiques dans cette expression en Java:

    a + b  * c / ( d - e )
1.    4    1   3     2
2.    4    2   3     1

Je comprends que le résultat est le même dans les deux réponses. Mais je voudrais comprendre pleinement le compilateur java logique. Ce qui est exécuté en premier, dans cet exemple, la multiplication ou l'expression entre parenthèses? Un lien vers la documentation qui couvre que ce serait utile.

Mise à JOUR: Merci les gars pour les réponses. La plupart de vous écrire que l'expression entre parenthèses est évalué en premier. Après avoir regardé les références fournies par Grodriguez j'ai créé peu de tests:

int i = 2;
System.out.println(i * (i=3)); //prints '6'
int j = 2;
System.out.println((j=3) * j); //prints '9'

Quelqu'un pourrait-il expliquer pourquoi ces tests produisent des résultats différents? Si l'expression entre parenthèses est évaluée la première je en droit d'attendre le même résultat - 9.

source d'informationauteur bancer

  1. 10

    Presque tout le monde jusqu'à présent, a confondu l'ordre d'évaluation avec priorité de l'opérateur. En Java, les règles de priorité de rendre l'expression équivalente à la suivante:

    a + (b  * c) / ( d - e )

    parce que * et / ont la même priorité et sont associativité à gauche.

    L'ordre d'évaluation est strictement défini comme de la main gauche opérande d'abord, puis à droite, puis l'opération (sauf pour les || et &&). Donc, l'ordre d'évaluation est:

      a
      b
      c
    *
      d
      e
    -
  /
+

    ordre de l'évaluation passe en bas de la page. L'Indentation reflète la structure de l'arbre de syntaxe

    Modifier

    En réponse à Grodriguez commentaires. Le programme suivant:

    public class Precedence 
{
    private static int a()
    {
        System.out.println("a");
        return 1;
    }   
    private static int b()
    {
        System.out.println("b");
        return 2;
    }
    private static int c()
    {
        System.out.println("c");
        return 3;
    }
    private static int d()
    {
        System.out.println("d");
        return 4;
    }
    private static int e()
    {
        System.out.println("e");
        return 5;
    }

    public static void main(String[] args) 
    {
        int x = a() + b() * c() / (d() - e());
        System.out.println(x);
    } 
}

    Génère la sortie

    a
b
c
d
e
-5

    qui montre clairement la multiplication est effectuée avant la soustraction.

  2. 13

    Comme JeremyP a bien montre nousla première réponse est correcte.

    En général, les règles suivantes s'appliquent:

    • Chaque opérande d'un opérateur est évaluée avant l'opération elle-même est effectuée (sauf pour ||&&et ? :)
    • Opérandes sont évalués de gauche à droite. La gauche opérande d'un opérateur binaire semble être pleinement évalués avant qu'une partie de la droite opérande est évaluée.
    • L'ordre de l'évaluation respecte les parenthèses et la priorité de l'opérateur:
      • Parenthèses sont évaluées en premier.
      • Les opérateurs sont évalués dans l'ordre de préséance.
      • Les opérateurs de même priorité sont évaluées de gauche à droite, sauf pour les opérateurs d'affectation qui sont évalués de droite à gauche.

    Noter que les deux premières règles expliquer le résultat dans votre deuxième question:

    int i = 2;
System.out.println(i * (i=3)); //prints '6'
int j = 2;
System.out.println((j=3) * j); //prints '9'

    Documentation de référence:

    http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#4779

    Tutoriel:

    http://download.oracle.com/javase/tutorial/java/nutsandbolts/operators.html

  3. 4

    Il évalue les expressions dans l'ordre suivant. Les noms de variables sont des expressions qui doivent être évalués.

    a + b * c / (d - e)
    2   3    5   6
      4        7
1         8
  9

    Donc, la réponse à votre question est #1. L'ordre des opérations qui détermine la forme de l'expression de l'arbre (qu'est-ce que le côté gauche de l'arbre, et qu'est-ce que le droit), mais le côté gauche est toujours évaluée en premier (et la racine est évaluée en dernier).

  4. 1

    J'imagine qu'il peut évaluer à quelque chose comme ça évaluation de gauche à droite.

    a+b*c/(d-e)

    Action           Left Value      Right Value
Start Add        a               b*c/(d-e)
Start Multiply   b               c
Calc Multiply (since it can)    
Start Divide     b*c             (d-e)
Start Subtract   d               e
Calc Subtract
Calc Divide
Calc Add

    Cela peut être considéré comme la création d'un arbre binaire représentant les calculs et ensuite travailler à partir de la feuille de nœuds, de gauche à droite, le calcul de choses. Malheureusement, mon ascii art n'est pas grand, mais voici une tentative de représenter l'arbre en question:

       Add
    /\
   /  \
  a    \
     Divide
       / \
      /   \
     /     \
    /       \
Multiply  Subtract
  /\         /\
 /  \       /  \
b    c     d    e

    Et j'ai fait quelques tests en C# (je sais ce n'est pas le même mais c'est là que mes intérêts se trouvent et les tests peuvent être facilement adapté) comme suit:

            f = 1;
Console.WriteLine((f=2) + (f) * (f) / ((f) - (f)-1));
Console.WriteLine(2 + 2 * 2 / (2 - 2 - 1));
f = 1;
Console.WriteLine((f) + (f=2) * (f) / ((f) - (f)-1));
Console.WriteLine(1 + 2 * 2 / (2 - 2 - 1));
f = 1;
Console.WriteLine((f) + (f) * (f = 2) / ((f) - (f)-1));
Console.WriteLine(1 + 1 * 2 / (2 - 2 - 1));
f = 1;
Console.WriteLine((f) + (f) * (f) / ((f=2) - (f)-1));
Console.WriteLine(1 + 1 * 1 / (2 - 2 - 1));
f = 1;
Console.WriteLine((f) + (f) * (f) / ((f) - (f=2)-1));
Console.WriteLine(1d + 1d * 1d / (1d - 2d - 1d));

    Les paires de la console.writeline déclarations sont algébrique, un (à l'aide de l'ensemble d'un numéro de truc) et une représentation numérique en montrant ce que le calcul de la réalité. Les paires de produire le même résultat que les autres.

    Comme on le voit, les arguments sont évalués dans l'ordre avec tout après la cession de la 2 et de ceux d'avant. Donc, l'ordre d'évaluation des choses, c'est simple, de gauche à droite je pense, mais l'ordre des calculs est ce que vous pouvez attendre qu'il soit.

    Je suppose qu'il peut être exécuté presque avec le copier-coller de test en JAVA...

    Il peut y avoir certains inaperçu hypothèses ici, donc si quelqu'un spot de la logique des défauts ici s'il vous plaît ne m'appelez sur eux et je vais travailler à travers.

  5. 0

    je suis en supposant que votre expression serait quelque chose comme

    x = a + b * c /( d - e )

    l'opérateur d'égalité, de droite à gauche, de l'ordre d'évaluation. si l'expression à droite de = sera évalué en premier.

    si votre reporter cette priorité graphique: http://www.java-tips.org/java-se-tips/java.lang/what-is-java-operator-precedence.html

    1) les supports seront évalués (d-e), permet de dire que (d - e) = f, donc l'expression devient alors
    x = a + b * c /f.

    2) * et //ont la même priorité, mais l'ordre d'évaluation est de gauche à droite * seront évaluées en premier donc permet de dire que b * c = g, donc l'expression devient x = a + g /f

    3) Maintenant /a la prochaine priorité, donc g /f sera évalué afin de permet de dire que h donc l'expression sera venu pour x = a + h,

    4) enfin, l'évaluation a + h

  6. 0

    Dans votre deuxième question, il semble que Java est l'évaluation de la partie entre parenthèses comme un devoir, pas une expression mathématique. Cela signifie que c'est n'effectuera pas de mise entre parenthèses des affectations dans le même ordre que les opérations entre parenthèses.

  7. -1

    Les résultats du calcul sont définies par le Opérateur Ordre de Préséance. Si les parenthèses ont la plus haute priorité ici, la multiplication et la division suivant le plus élevé, et de l'addition et de la soustraction plus bas. Les opérateurs de même priorité sont évaluées de gauche à droite. Donc l'expression en question est équivalent à:

        a + (b  * c) / ( d - e ))

    Cependant il y a une légère différence entre ce qui est normalement entend par "être évaluées en premier" et la priorité de l'opérateur pour obtenir la bonne réponse.

    "d-e" n'est pas nécessairement effectivement calculés avant de "un" est calculé. Ce joli beaucoup ne fait aucune différence, à moins que l'un des "variables" dans l'expression est en fait une fonction. La norme Java ne permet pas de spécifier l'ordre d'évaluation des composants d'une expression.

  8. -1
    a + b * c / ( d - e )
1         1
2
3

    Le point de l'ensemble de la priorité des opérateurs est de convertir l'expression dans un arbre de syntaxe. Ici le * et - sont au même niveau de l'arbre. Ce qui est évalué en premier est sans importance pour la suite et non garantis.

    Modifier: Désolé, j'ai confondu par mon C en arrière-plan. Comme d'autres l'ont souligné, Java a un "Évaluer Gauche Opérande Première" règle. L'application de cette règle à / vous dit que * est évalué en premier (votre première réponse).