Effet d’un opérateur binary sur un booléen en Java

Les opérateurs binarys sont supposés parcourir des variables et les exploiter bit par bit. Dans le cas des entiers, des longs, les caractères ont un sens. Ces variables peuvent contenir toute la gamme de valeurs imposées par leur taille.

Dans le cas de booléens, un booléen ne peut contenir que deux valeurs. 1 = vrai ou 0 = faux. Mais la taille du booléen n’est pas définie. Il peut être aussi gros qu’un octet ou un peu petit.

Alors, quel est l’effet de l’utilisation d’un opérateur bit à bit sur un booléen? La JVM le traduit-elle essentiellement vers un opérateur logique normal et continue-t-elle? Traite-t-il le booléen comme une entité à un seul bit aux fins de l’opération? Ou le résultat est-il indéfini avec la taille d’un booléen?

Les opérateurs &, ^, et | sont des opérateurs binarys lorsque les opérandes sont des types intégrales primitifs. Ce sont des opérateurs logiques lorsque les opérandes sont booléens et que leur comportement dans ce dernier cas est spécifié. Consultez la section 15.22.2 de la spécification du langage Java pour plus de détails.

L’utilisation de l’opérateur binary permet de contourner le comportement en court-circuit:

 boolean b = booleanExpression1() && booleanExpression2(); boolean b = booleanExpression1() & booleanExpression2(); 

Si booleanExpression1() évalué à false , alors
booleanExpression2() n’est pas évalué dans le premier cas, et
booleanExpression2() (et tous les effets secondaires possibles) est évalué dans le second cas,

Au-delà de ce qui est couvert dans les autres réponses, il convient de noter que && et || ont une priorité différente de & et | .

Extrait du tableau de priorité (avec la priorité la plus élevée en haut).

 bitwise AND & bitwise exclusive OR ^ bitwise inclusive OR | logical AND && logical OR || 

Qu’est-ce que cela signifie pour vous?

Absolument rien, du moment que vous vous en tenez à seulement & et | ou seulement && et || .

Mais depuis la prééminence est supérieure à celle de && (par opposition à || , qui a moins de priorité), les mélanger librement peut entraîner un comportement inattendu.

Donc, a && b | c && d a && b | c && d est identique à a && (b | c) && d ,
par opposition à a && b || c && d a && b || c && d qui serait (a && b) || (c && d) (a && b) || (c && d) .

Pour prouver qu’ils ne sont pas les mêmes, considérez un extrait de la table de vérité:

 a | b | c | d | (b|c) | (a&&b) | (c&&d) | a && (b|c) && d | (a&&b) || (c&&d) F | T | T | T | T | F | T | F | T ^ ^ |- not the same -| 

Si vous voulez que la priorité soit supérieure à ET, vous pouvez utiliser | et && ensemble, mais ce n’est pas recommandé.

Mais vous devriez vraiment les mettre entre parenthèses pour clarifier la préséance lorsque vous utilisez des symboles différents, par exemple (a && b) || c (a && b) || c (entre parenthèses pour préciser la priorité), a && b && c (pas de parenthèse nécessaire).

Même si cela fonctionnera, vous ne devriez pas le faire. Les spécifications de langage définissent les opérateurs de bit uniquement lorsque les deux opérandes sont de type entier primitif ou que les deux sont de type booléen. Je dirais que pour tout autre cas, les résultats ne sont pas définis:

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