Opérateurs Bitwise & vs Logiques &&

1. Introduction

En Java, nous avons deux façons de dire «ET». Mais lequel utiliser?

Dans ce didacticiel, nous examinerons les différences entre & et &&. Et nous en apprendrons davantage sur les opérations au niveau du bit et les courts-circuits en cours de route.

2. Utilisation de ET au niveau du bit

L'opérateur ET (&) au niveau du bit compare chaque chiffre binaire de deux entiers et renvoie 1 si les deux sont 1, sinon, il renvoie 0.

Jetons un œil à deux entiers:

int six = 6; int five = 5;

Ensuite, appliquons un opérateur AND au niveau du bit sur ces nombres:

int resultShouldBeFour = six & five; assertEquals(4, resultShouldBeFour);

Pour comprendre cette opération, regardons la représentation binaire de chaque nombre:

Binary of decimal 4: 0100 Binary of decimal 5: 0101 Binary of decimal 6: 0110

L'opérateur & effectue un ET logique sur chaque bit et renvoie un nouveau nombre binaire:

0110 0101 ----- 0100

Enfin, notre résultat - 0100 - peut être reconverti en nombre décimal - 4 .

Voyons le code Java de test:

int six = 6; int five = 5; int resultShouldBeFour = six & five; assertEquals(4, resultShouldBeFour);

2.1. Utilisation de et avec des booléens

De plus, nous pouvons utiliser l' opérateur binaire AND ( & ) avec des opérandes booléens . Il renvoie vrai uniquement si les deux opérandes sont vrais , sinon, il renvoie faux.

Prenons trois variables booléennes :

boolean trueBool = true; boolean anotherTrueBool = true; boolean falseBool = false;

Ensuite, appliquons un opérateur AND au niveau du bit aux variables trueBool et anotherTrueBool :

boolean trueANDtrue = trueBool & anotherTrueBool;

Ensuite, le résultat sera vrai .

Ensuite, appliquons un opérateur AND au niveau du bit sur trueBool et falseBool :

boolean trueANDFalse = trueBool & falseBool;

Dans ce cas, le résultat sera faux .

Voyons le code Java de test:

boolean trueBool = true; boolean anotherTrueBool = true; boolean falseBool = false; boolean trueANDtrue= trueBool & anotherTrueBool; boolean trueANDFalse = trueBool & falseBool; assertTrue(trueANDtrue); assertFalse(trueANDFalse);

3. Utilisation de ET logique

Comme & , l' opérateur logique AND ( && ) compare la valeur de deux variables ou expressions booléennes. Et, il renvoie également vrai uniquement si les deux opérandes sont vrais , sinon, il renvoie faux .

Prenons trois variables booléennes :

boolean trueBool = true; boolean anotherTrueBool = true; boolean falseBool = false;

Ensuite, appliquons un opérateur logique AND sur les variables trueBool et anotherTrueBool :

boolean trueANDtrue = trueBool && anotherTrueBool;

Ensuite, le résultat sera vrai .

Ensuite, appliquons un opérateur logique AND sur trueBool et falseBool :

boolean trueANDFalse = trueBool && falseBool;

Dans ce cas, le résultat sera faux .

Voyons le code Java de test:

boolean trueBool = true; boolean anotherTrueBool = true; boolean falseBool = false; boolean anotherFalseBool = false; boolean trueANDtrue = trueBool && anotherTrueBool; boolean trueANDFalse = trueBool && falseBool; boolean falseANDFalse = falseBool && anotherFalseBool; assertTrue(trueANDtrue); assertFalse(trueANDFalse); assertFalse(falseANDFalse);

3.1. Court-circuit

Alors, quelle est la différence? Eh bien, l' opérateur && court-circuite. Cela signifie qu'il n'évalue pas l'opérande ou l'expression de droite lorsque l'opérande ou l'expression de gauche est faux .

Prenons deux expressions évaluées comme fausses:

First Expression: 2<1 Second Expression: 4<5 

Lorsque nous appliquons un opérateur logique AND sur les expressions 2 <1 et 4 <5, alors il évalue uniquement la première expression 2 <1 et renvoie false.

boolean shortCircuitResult = (2<1) && (4<5); assertFalse(shortCircuitResult);

3.2. Utilisation de && avec des entiers

Nous pouvons utiliser l'opérateur & avec des types booléens ou numériques mais && ne peut être utilisé qu'avec des opérandes booléens. Son utilisation avec des opérandes entiers entraîne une erreur de compilation:

int five = 2; int six = 4; int result = five && six;

4. Comparaison

  1. L'opérateur & évalue toujours les deux expressions, tandis que l'opérateur && évalue la deuxième expression uniquement si la première est vraie
  2. & compare chaque opérande au niveau du bit, alors que && ne fonctionne que sur les booléens

5. Conclusion

Dans cet article, nous avons utilisé l' opérateur binaire & pour comparer des bits de deux chiffres résultant en un nouveau chiffre. De plus, nous avons utilisé l' opérateur logique && pour comparer deux booléens, résultant en une valeur booléenne.

Nous avons également constaté des différences clés entre les deux opérateurs.

Comme toujours, vous pouvez trouver le code de ce tutoriel sur GitHub.