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

Question

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 ?

Answer 1

Outre le fait que && et || sont des raccourcis, il faut également tenir compte de la préséance des opérateurs lorsque l'on mélange les deux formes. Je pense qu'il ne sera pas immédiatement évident pour tout le monde que result1 et result2 contiennent des valeurs différentes.

boolean a = true;
boolean b = false;
boolean c = false;

boolean result1 = a || b && c; //is true;  evaluated as a || (b && c)
boolean result2 = a  | b && c; //is false; evaluated as (a | b) && c

Answer 2

& est un opérateur bit à bit plus utilisé pour vérifier les deux conditions car parfois nous devons évaluer les deux conditions. Mais l'opérateur logique && passe à la deuxième condition lorsque la première condition est vraie.

Answer 3

Toutes les réponses sont great et il semble que no plus de réponse is needed mais je voulais juste souligner quelque chose sur && opérateur appelé dependent condition

Dans les expressions utilisant l'opérateur &&, une condition - nous l'appellerons le dependent condition -peut exiger qu'une autre condition soit vraie pour que l'évaluation de la condition dépendante ait un sens.

Dans ce cas, la condition dépendante doit être placée après l'opérateur && pour éviter les erreurs.

Considérons l'expression (i != 0) && (10 / i == 2) . La condition dépendante (10 / i == 2) debe appear after el && pour éviter toute possibilité de division par zéro.

un autre exemple (myObject != null) && (myObject.getValue() == somevaluse)

et autre chose : && et || sont appelés évaluation des courts-circuits parce que le deuxième argument est exécuté ou évalué only if el first l'argument ne not suffice a determine el value de la expression

Références : Java™ How To Program (Early Objects), dixième édition

Answer 4

En ce qui concerne les opérateurs AND et OR, Java dispose de deux types d'évaluation, à savoir Short-Circuit evaluation et full evaluation .

&& || Évaluation des courts-circuits

Évaluation des courts-circuits vous permet de ne pas évaluer le côté droit des expressions ET et OU, lorsque le résultat global peut être prédit à partir de la valeur du côté gauche.

int numberOne = 1;
int numberTwo = 2;
boolean result = false;

// left-side is false so the the overall result CAN be predicted without evaluating the right side.
// numberOne will be 1, numberTwo will be 2, result will be false
result = (numberOne > numberTwo) && (++numberOne == numberTwo);

System.out.println(numberOne); // prints 1
System.out.println(numberTwo); // prints 2
System.out.println(result);    // prints false

// left-side is true so the the overall result CAN NOT be predicted without evaluating the right side.
// numberOne will be 2, numberTwo will be 2, result will be true
result = (numberTwo > numberOne) && (++numberOne == numberTwo);

System.out.println(numberOne); // prints 2
System.out.println(numberTwo); // prints 2
System.out.println(result);    // prints true

& | ^ Évaluation complète

Bien que dans certains cas il soit possible de prédire le résultat, il est nécessaire d'évaluer le côté droit.

int numberOne = 1;
int numberTwo = 2;
boolean result = false;

// left-side is false so the the overall result will be false BUT the right side MUST be evaluated too.
// numberOne will be 2, numberTwo will be 2, result will be false
result = (numberOne > numberTwo) & (++numberOne == numberTwo);

System.out.println(numberOne); // prints 2
System.out.println(numberTwo); // prints 2
System.out.println(result);    // prints false

Avis :

1. Remarquez que pour XOR ( ^ ), il n'y a pas de court-circuit, car les deux côtés sont toujours nécessaires pour déterminer le résultat global.
2. Notez que d'autres noms possibles pour l'évaluation du court-circuit sont minimal evaluation et McCarthy evaluation .
3. Il n'est pas recommandé de mélanger la logique booléenne et les actions dans la même expression.
4. & peut également agir comme un opérateur ET par bit, ce qui est très académique et peut être utilisé en cryptographie. Lorsque les deux bits sont à 1, le résultat est 1, ou si l'un des bits n'est pas à 1, le résultat est 0. (Vérifiez le code suivant)

AND Exemple de bitwise :

byte a = 5;              // 00000101
byte b = 3;              // 00000011
byte c = (byte) (a & b); // 00000001 (c is 1)

Answer 5

Presque tous les points de comparaison sont très bien couverts dans toutes les réponses. Je veux juste ajouter un exemple. Pour montrer comment le résultat change en fonction de l'opérateur utilisé. Considérons l'exemple ci-dessous

int a = 10;
if(++a==10 & ++a==12) {
    ++a;
}
System.out.println(a); //12

Dans le code ci-dessus, nous utilisons l'opérateur bitwise &. Il évaluera donc les deux arguments (gauche et droite) sans tenir compte du résultat individuel.

donc a sera incrémenté 2 fois dans if condition . Mais comme la condition ne deviendra pas vraie, elle n'entrera pas dans la boucle if et le 3ème incrément ne se produira pas. La valeur finale de a sera donc de 12 dans ce cas.

Supposons maintenant, dans le même exemple ci-dessus, que nous utilisions l'opérateur && en court-circuit. alors après avoir évalué ++a==10 à false, il ne va pas aller vérifier le second argument. Et donc la valeur finale d'un prétendu 11.

int a = 10;
if(++a==10 && ++a==12) {
    ++a;
}
System.out.println(a); //11

Sur cette base, nous pouvons dire que la performance de l'opérateur & au sens des bits est relativement faible par rapport à l'opérateur && en court-circuit. En effet, l'opérateur bitwise évaluera les deux arguments, quel que soit le résultat du premier argument. Alors que l'opérateur && arrêtera d'évaluer le second argument si le résultat du premier argument est faux.

Une autre différence entre les deux est que l'opérateur Bitwise & est applicable aux types booléens et intégraux. Alors que l'opérateur && en court-circuit n'est applicable que pour le type booléen.

On peut écrire

System.out.println(4 & 5); // 4

Mais si nous essayons d'écrire comme ,

System.out.println(4 && 5);

Ensuite, il y aura une erreur disant,

Mauvais types d'opérandes pour l'opérateur binaire "&&".