216 votes

Quelle est la différence entre & et && en Java ?

J'ai toujours pensé que && en Java est utilisé pour vérifier si ses deux opérandes booléens sont true et le & est utilisé pour effectuer des opérations binaires sur deux types de nombres entiers.

Récemment, j'ai appris que & L'opérateur peut aussi être utilisé pour vérifier si ses deux opérandes booléens sont true la seule différence étant qu'il vérifie l'opérande RHS même si l'opérande LHS est faux.

Est-ce que le & en Java est surchargé en interne ? Ou y a-t-il un autre concept derrière cela ?

356voto

ITroubs Points 4570

& <-- vérifie les deux opérandes
&& <-- arrête l'évaluation si le premier opérande évalue à faux puisque le résultat sera faux.

(x != 0) & (1/x > 1) <-- cela signifie évaluer (x != 0) alors évalue (1/x > 1) Le problème est que pour x=0, une exception sera levée.

(x != 0) && (1/x > 1) <-- cela signifie évaluer (x != 0) et seulement si cela est vrai, alors évaluez (1/x > 1) Ainsi, si vous avez x=0, ceci est parfaitement sûr et ne lèvera pas d'exception si (x != 0) évalue à false, l'ensemble évalue directement à false sans évaluer la fonction (1/x > 1) .

EDIT :

exprA | exprB <-- cela signifie évaluer exprA alors évalue exprB alors faites le | .

exprA || exprB <-- cela signifie évaluer exprA et seulement si c'est false alors évalue exprB et faire le || .

64voto

suat Points 1608

En plus de ne pas être un évaluateur paresseux en évaluant les deux opérandes, je pense que les principales caractéristiques des opérateurs bitwise comparent chaque octet des opérandes comme dans l'exemple suivant :

int a = 4;
int b = 7;
System.out.println(a & b); // prints 4
//meaning in an 32 bit system
// 00000000 00000000 00000000 00000100
// 00000000 00000000 00000000 00000111
// ===================================
// 00000000 00000000 00000000 00000100

37voto

Torres Points 1641
boolean a, b;

Operation     Meaning                       Note
---------     -------                       ----
   a && b     logical AND                    short-circuiting
   a || b     logical OR                     short-circuiting
   a &  b     boolean logical AND            not short-circuiting
   a |  b     boolean logical OR             not short-circuiting
   a ^  b     boolean logical exclusive OR
  !a          logical NOT

short-circuiting        (x != 0) && (1/x > 1)   SAFE
not short-circuiting    (x != 0) &  (1/x > 1)   NOT SAFE

13voto

developer Points 2924

Cela dépend du type d'arguments...

Pour les arguments entiers, l'esperluette simple ("&") est l'opérateur "AND" au sens large. L'esperluette double ("&&") n'est définie que pour deux arguments booléens.

Pour les arguments booléens, l'esperluette simple constitue l'opérateur "ET logique" (inconditionnel) tandis que l'esperluette double ("&&") est l'opérateur "ET logique conditionnel". En d'autres termes, l'esperluette simple évalue toujours les deux arguments, tandis que l'esperluette double n'évalue le second argument que si le premier est vrai.

Pour tous les autres types et combinaisons d'arguments, une erreur de compilation doit se produire.

10voto

Prince John Wesley Points 22418

&& est un opérateur de court-circuit alors que & est un opérateur ET.

Essayez ça.

    String s = null;
    boolean b = false & s.isEmpty(); // NullPointerException
    boolean sb = false && s.isEmpty(); // sb is false

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X