Dans ce didacticiel, nous allons en apprendre davantage sur l'opérateur bit à bit et les différents types d'opérateurs de décalage en Java à l'aide d'exemples.
En Java, les opérateurs au niveau du bit effectuent des opérations sur des données entières au niveau du bit individuel. Ici, les données entier comprend byte, short, intet longtypes de données.
Il existe 7 opérateurs pour effectuer des opérations au niveau du bit en Java.
| Opérateur | La description |
|---|---|
| | OU au niveau du bit |
& | ET au niveau du bit |
^ | XOR au niveau du bit |
~ | Complément au niveau du bit |
<< | Décalage à gauche |
>> | Décalage droit signé |
>>> | Décalage droit non signé |
1. Opérateur Java Bitwise OR
L' |opérateur OR au niveau du bit renvoie 1 si au moins l'un des opérandes est 1. Sinon, il renvoie 0.
La table de vérité suivante montre le fonctionnement de l'opérateur OR au niveau du bit. Soit a et b deux opérandes qui ne peuvent prendre que des valeurs binaires, c'est-à-dire 1 ou 0.
| une | b | a | b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
La table ci-dessus est connue sous le nom de «Table de vérité» pour l'opérateur OR au niveau du bit.
Regardons l'opération OR au niveau du bit de deux entiers 12 et 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) Bitwise OR Operation of 12 and 25 00001100 | 00011001 ____________ 00011101 = 29 (In Decimal)
Exemple 1: OU au niveau du bit
class Main ( public static void main(String() args) ( int number1 = 12, number2 = 25, result; // bitwise OR between 12 and 25 result = number1 | number2; System.out.println(result); // prints 29 ) )
2. Opérateur Java Bitwise AND
L' &opérateur AND au niveau du bit renvoie 1 si et seulement si les deux opérandes sont 1. Sinon, il renvoie 0.
Le tableau suivant illustre le fonctionnement de l'opérateur AND au niveau du bit. Soit a et b deux opérandes qui ne peuvent prendre que des valeurs binaires, c'est-à-dire 1 et 0.
| une | b | un B |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Jetons un coup d'œil à l'opération ET au niveau du bit de deux entiers 12 et 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) // Bitwise AND Operation of 12 and 25 00001100 & 00011001 ____________ 00001000 = 8 (In Decimal)
Exemple 2: ET au niveau du bit
class Main ( public static void main(String() args) ( int number1 = 12, number2 = 25, result; // bitwise AND between 12 and 25 result = number1 & number2; System.out.println(result); // prints 8 ) )
3. Opérateur Java Bitwise XOR
L' ^opérateur XOR au niveau du bit renvoie 1 si et seulement si l'un des opérandes est 1. Cependant, si les deux opérandes sont 0 ou si les deux sont 1, le résultat est 0.
La table de vérité suivante montre le fonctionnement de l'opérateur XOR au niveau du bit. Soit a et b deux opérandes qui ne peuvent prendre que des valeurs binaires, c'est-à-dire 1 ou 0.
| une | b | un B |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Examinons l'opération XOR au niveau du bit de deux entiers 12 et 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) // Bitwise XOR Operation of 12 and 25 00001100 00011001 ____________ 00010101 = 21 (In Decimal)
Exemple 4: XOR au niveau du bit
class Main ( public static void main(String() args) ( int number1 = 12, number2 = 25, result; // bitwise XOR between 12 and 25 result = number1 number2; System.out.println(result); // prints 21 ) )
4. Opérateur de complément Java Bitwise
L'opérateur de complément au niveau du bit est un opérateur unaire (fonctionne avec un seul opérande). Il est indiqué par ~.
Il change les chiffres binaires 1 en 0 et 0 en 1 .
Opérateur de complément Java Bitwise
It is important to note that the bitwise complement of any integer N is equal to - (N + 1). For example,
Consider an integer 35. As per the rule, the bitwise complement of 35 should be -(35 + 1) = -36. Now let's see if we get the correct answer or not.
35 = 00100011 (In Binary) // using bitwise complement operator ~ 00100011 __________ 11011100
In the above example, we get that the bitwise complement of 00100011 (35) is 11011100. Here, if we convert the result into decimal we get 220.
However, it is important to note that we cannot directly convert the result into decimal and get the desired output. This is because the binary result 11011100 is also equivalent to -36.
To understand this we first need to calculate the binary output of -36.
2's Complement
In binary arithmetic, we can calculate the binary negative of an integer using 2's complement.
1's complement changes 0 to 1 and 1 to 0. And, if we add 1 to the result of the 1's complement, we get the 2's complement of the original number. For example,
// compute the 2's complement of 36 36 = 00100100 (In Binary) 1's complement = 11011011 2's complement: 11011011 + 1 _________ 11011100
Ici, nous pouvons voir que le complément à 2 de 36 (soit -36 ) est 11011100 . Cette valeur équivaut au complément au niveau du bit de 35 .
Par conséquent, nous pouvons dire que le complément bit à bit de 35 est - (35 + 1) = -36 .
Exemple 3: Complément au niveau du bit
class Main ( public static void main(String() args) ( int number = 35, result; // bitwise complement of 35 result = ~number; System.out.println(result); // prints -36 ) )
Opérateurs Java Shift
Il existe trois types d'opérateurs de décalage en Java:
- Décalage gauche signé (<<)
- Décalage droit signé (>>)
- Décalage droit non signé (>>>)
5. Opérateur Java Left Shift
L'opérateur de décalage gauche décale tous les bits vers la gauche d'un certain nombre de bits spécifiés. Il est indiqué par <<.
Opérateur de décalage gauche Java 1 bit
As we can see from the image above, we have a 4-digit number. When we perform a 1 bit left shift operation on it, each individual bit is shifted to the left by 1 bit.
As a result, the left-most bit (most-significant) is discarded and the right-most position(least-significant) remains vacant. This vacancy is filled with 0s.
Example 5: Left Shift Operators
class Main ( public static void main(String() args) ( int number = 2; // 2 bit left shift operation int result = number << 2; System.out.println(result); // prints 8 ) )
5. Java Signed Right Shift Operator
The signed right shift operator shifts all bits towards the right by a certain number of specified bits. It is denoted by >>.
When we shift any number to the right, the least significant bits (rightmost) are discarded and the most significant position (leftmost) is filled with the sign bit. For example,
// right shift of 8 8 = 1000 (In Binary) // perform 2 bit right shift 8>> 2: 1000>> 2 = 0010 (equivalent to 2)
Ici, nous effectuons le décalage droit de 8 (c'est-à-dire que le signe est positif). Par conséquent, il n'y a pas de bit de signe. Ainsi, les bits les plus à gauche sont remplis de 0 (représente un signe positif).
// right shift of -8 8 = 1000 (In Binary) 1's complement = 0111 2's complement: 0111 + 1 _______ 1000 Signed bit = 1 // perform 2 bit right shift 8>> 2: 1000>> 2 = 1110 (equivalent to -2)
Ici, nous avons utilisé le bit 1 signé pour remplir les bits les plus à gauche.
Exemple 6: opérateur de décalage droit signé
class Main ( public static void main(String() args) ( int number1 = 8; int number2 = -8; // 2 bit signed right shift System.out.println(number1>> 2); // prints 2 System.out.println(number2>> 2); // prints -2 ) )
7. Opérateur de décalage vers la droite Java non signé
Java fournit également un décalage à droite non signé. Il est indiqué par >>>.
Ici, la position la plus à gauche vacante est remplie avec 0 au lieu du bit de signe. Par exemple,
// unsigned right shift of 8 8 = 1000 8>>> 2 = 0010 // unsigned right shift of -8 -8 = 1000 (see calculation above) -8>>> 2 = 0010
Exemple 7: décalage vers la droite non signé
class Main ( public static void main(String() args) ( int number1 = 8; int number2 = -8; // 2 bit signed right shift System.out.println(number1>>> 2); // prints 2 System.out.println(number2>>> 2); // prints 1073741822 ) )
Comme nous pouvons le voir, l'opérateur de décalage à droite signé et non signé renvoie des résultats différents pour les bits négatifs. Pour en savoir plus, visitez la Différence entre >> et >>>.
