Est-ce que Java interpréterait cette expression booléenne comme je le voulais?

Question

C'est ce que je veux: !A || (A && B && C) Est-ce l'équivalent de l'original? !A || A && B && C pourquoi ou pourquoi pas?

Answer 1

Oui, ils sont les mêmes. Ainsi est le !A || B && C simplifié.

L'opérateur && a une priorité plus élevée que l'opérateur ||, donc les parenthèses autour de l'opération && sont inutiles.

Answer 2

&& ont la priorité que ||. les deux expressions sont les mêmes. parce A && B && C sera évalué d'abord

Voici votre operator Precedence guid in Java.

Answer 3

Pour être sûr et mieux lisible, je suggère de mettre les parenthèses autour des opérations pour que la préséance soit claire.

EDIT: Ce n'est pas seulement mon opinion. C'est une recomondation selon MISRA-c (règle 34) Voir electronicDesing en bas.

Et puisque la précendence de & & est terminée || ce sont les mêmes.

Answer 4

Oui, il le ferait.

Regardez le Java operator precedence.

Comme vous le remarquerez, logique et a une priorité plus élevée que logique OU ce qui signifie que &&« se fixe plus serré que »||. En outre unaire ! a également une priorité plus élevée que || donc il affectera seulement le A initial.

Answer 5

Oui les 2 expressions sont égales. La raison pour laquelle vous n'avez pas besoin de parenthèses dans ces expressions spécifiques est que l'opérateur & & a la priorité sur le || opérateur.

Edit: Voici un beau test unitaire qui vérifie l'égalité pour toutes les valeurs possibles:

package main; 

import junit.framework.Assert; 

public class Test 
{ 
    enum BOOL 
    { 
     TRUE(true), FALSE(false); 

     private boolean m_val; 

     BOOL(boolean val) 
     { 
      m_val = val; 
     } 

     public boolean getValue() 
     { 
      return m_val; 
     } 
    } 

    @org.junit.Test 
    public void test1() 
    { 
     boolean a,b,c; 
     for (BOOL boola : BOOL.values()) 
     { 
      for (BOOL boolb : BOOL.values()) 
      { 
       for (BOOL boolc : BOOL.values()) 
       { 
        a = boola.getValue(); 
        b = boolb.getValue(); 
        c = boolc.getValue(); 
        boolean exp1 = !a || (a && b && c); 
        boolean exp2 = !a || a && b && c; 
        Assert.assertEquals(exp1, exp2); 
       } 
      } 
     } 
    } 
} 

Le test passe, de sorte que les 2 expressions sont en effet égaux.

Answer 6

La priorité de l'opérateur d'un bit et (& &) est supérieure à celle du bit ou (||). Voir http://download.oracle.com/javase/tutorial/java/nutsandbolts/operators.html

Cela signifie que les deux expressions logiques sont égaux A & & B & & partie C de la deuxième epxression logique est évalué d'abord, puis il est combiné avec le!A comme vous pouvez le voir dans le tableau suivant où F1 est votre première expression et F2 votre deuxième

A B C F1 F2 
0 0 0 1 1 
0 0 1 1 1 
0 1 0 1 1 
0 1 1 1 1 
1 0 0 0 0 
1 0 1 0 0 
1 1 0 0 0 
1 1 1 1 1 

Voici également le code java pour tester cette

public class TestLogic { 
    public static void main(String[] args) { 
     for (int i=0;i<8;i++) { 
      boolean a=bit(i,3); 
      boolean b=bit(i,2); 
      boolean c=bit(i,1); 
      System.out.println(asZeroOne(a)+asZeroOne(b)+asZeroOne(c)+"\t"+asZeroOne(f1(a,b,c))+"\t"+asZeroOne(f2(a,b,c))); 
     } 
    } 

    static boolean f1(boolean a, boolean b, boolean c) { 
     return !a || (a && b && c); 
    } 

    static boolean f2(boolean a, boolean b, boolean c) { 
     return !a || a && b && c; 
    } 

    static boolean bit(int value, int bitnumber) { 
     int bitmask = (int) Math.pow(2, bitnumber-1); 
     return (value & bitmask)>0; 
    } 
    static String asZeroOne(boolean b) { 
     return (b?"1":"0"); 
    } 

}