Quelle est la principale différence entre les opérateurs booléens `&&`/`||` et les opérateurs au niveau du bit `&`/`|` en Java ?

Découvrir les subtilités des opérateurs booléens : & vs && et | vs ||

Alors que le comportement des opérateurs logiques booléens && (Conditionnel-Et) et || (Conditional-Or) peut sembler familier, il existe des homologues, & (Bitwise-And) et | (Bitwise-Or), qui méritent attention. Ces opérateurs au niveau du bit, opérant au niveau du bit, offrent un ensemble de règles différent.

Considérez l'exemple suivant pour comprendre leur fonctionnalité :

int a = 6; // Binary: 110
int b = 4; // Binary: 100

// Bitwise AND

int c = a & b;
//   110
// & 100
// -----
//   100

// Bitwise OR

int d = a | b;
//   110
// | 100
// -----
//   110

System.out.println(c); // Output: 4
System.out.println(d); // Output: 6

Dans cette démonstration, les opérateurs au niveau du bit effectuent opérations logiques sur chaque bit correspondant des entiers d’entrée, aboutissant aux valeurs modifiées. Le Bitwise-AND (&) et le Bitwise-OR (|), contrairement à leurs homologues logiques, fonctionnent au niveau du bit, considérant les entrées comme des séquences de 0 et de 1.

Il est important de noter que le && et || les opérateurs obéissent à une règle de « court-circuit ». Cela signifie que l'évaluation de la deuxième condition est ignorée lorsque la première condition est respectivement évaluée comme fausse ou vraie, empêchant ainsi toute erreur ou exception potentielle.

Au contraire, & et | ne présentent pas ce comportement. Ils examinent méticuleusement chaque condition de la clause, évaluant toutes les expressions fournies quel que soit le résultat des conditions précédentes. Cette distinction devient cruciale lorsqu'une des expressions peut déclencher une exception, comme le montre cet exemple :

int a = null;

if ((a != null) & (a.something == 3)) {
    // Safe: 'a.something' will not be evaluated if 'a' is null
}

if ((a != null) & (a.something == 3)) {
    // Unsafe: 'a.something' will be evaluated even if 'a' is null, potentially raising an exception
}

En comprenant ces différences fondamentales entre les opérateurs booléens, vous pouvez exploiter efficacement leur puissance dans votre code, garantissant ainsi une et un comportement optimisé.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!