Java Bitwise : vue d’ensemble des opé­ra­teurs et leur fonction

Avec Java Bitwise, vous pouvez manipuler des bits in­di­vi­duels à loisir. Les sept opé­ra­teurs au total sont toujours très si­mi­laires et suivent des règles précises faciles à assimiler.

Que sont les opé­ra­teurs bit à bit et à quoi servent-ils ?

Les opé­ra­teurs Java sont un outil essentiel pour manipuler le langage de pro­gram­ma­tion. Outre leurs nom­breuses autres capacités et fonctions, ils vous offrent la pos­si­bi­lité de manipuler les plus petites unités d’in­for­ma­tion possibles. Ces bits (binary digits) ont leur propre système de nu­mé­ra­tion basé sur les valeurs 0 et 1. Si vous voulez main­te­nant in­ter­ro­ger les valeurs binaires bit par bit, vous avez besoin d’un Bitwise operator en Java. Vous pouvez appliquer cela aux types de données nu­mé­riques (octet, char, int, short, long).

Si vous ne devez pas recourir à cette fonction tous les jours, elle s’avère utile dans certains cas : en l’oc­cur­rence, si vous voulez éco­no­mi­ser de l’espace lors de la con­ver­sion des données, utiliser l’opérateur XOR ou si vous voulez vraiment changer un seul bit. Elle est également à la base de toutes les opé­ra­tions de com­mu­ta­tion plus avancées. Il est donc utile de se pencher sur le fonc­tion­ne­ment fon­da­men­tal de Java Bitwise.

Quels sont les opé­ra­teurs Java Bitwise ?

Il existe un total de sept dif­fé­rents « Bitwise Operators in Java ». Pour une meilleure com­pré­hen­sion, nous partons des deux opérandes « a » et « b ».

• ~ (com­plé­ment ou « NON bit à bit ») : cet opérateur inverse chaque bit. Un 0 devient un 1 et un 1 devient un 0.
• & (« ET bit à bit ») : cet opérateur sort un 1 si les deux opérandes sont également 1. Si ce n’est pas le cas, un 0 est émis.
• | (« OU bit à bit ») : cet opérateur produit un 1 si l’une des deux opérandes a également cette valeur.
• ^ (XOR ou « OU exclusif bit à bit ») : cet opérateur sort un 0 si les deux opérandes ont la même valeur. Sinon, il produit un 1.
• << (décalage à gauche) : cet opérateur déplace l’opérande a de b positions vers la gauche. Si ceci donne lieu à des blancs, ceux-ci sont remplis avec 0.
• >> (décalage à droite avec un signe, arith­mé­tique) : cet opérateur déplace tous les bits de a de b positions vers la droite. Si le bit avec la valeur la plus élevée a été défini avant même l’exécution, il reste défini même après l’exécution. Les nombres négatifs restent ainsi négatifs.
• >>> (décalage à droite sans signe, logique) : cet opérateur décale les bits de a de b positions vers la droite. Les blancs sont toujours remplis avec 0.

NON bit à bit

L’opérateur Java Bitwise « NON bit à bit » est re­pré­senté par un tilde (~). Il change tous les bits en leurs opposés et trans­forme ainsi les zéros en uns et les uns en zéros. Prenons le chiffre 20 pour notre exemple. En tant que nombre binaire, il ressemble à ceci : 10100. Si nous utilisons main­te­nant cet opérateur, celui-ci commute chaque bit du nombre. De 10100, on obtient 01011 grâce à cet opérateur. Il s’agit de la valeur de l’ex­pres­sion « ~20 ». Si nous con­ver­tis­sons ce nombre binaire en nombre décimal, nous obtenons la valeur -21. Si vous voulez essayer cela dans le code, entrez ce qui suit et imprimez la sortie en utilisant la commande Java System.out.println.

public class Main {
	public static void main(String[] args) {
	int Valeur1 = 20;
	System.out.println(~Valeur1);
}
}

Si vous avez tout saisi cor­rec­te­ment, la sortie doit main­te­nant afficher « -21 ».

ET bit à bit

L’opérateur ET bit à bit compare deux nombres dans leur forme binaire bit par bit. Ainsi, le premier bit du premier nombre est mis en cor­res­pon­dance avec le premier bit du second nombre, le second bit avec le second bit, et ainsi de suite. Si les deux bits sont 1, un 1 est également émis. Si ce n’est pas le cas parce que soit les deux bits, soit un seul bit est 0, un 0 est émis. Prenons les deux nombres décimaux 18 et 25 pour notre exemple. 18 cor­res­pond à 10010 en tant que nombre binaire. Le 25 donne 11001 en notation binaire. Nous comparons main­te­nant ces deux nombres pour en tirer un troisième nombre. Nous les écrivons l’un après l’autre pour un meilleur aperçu :

18 = 10010 25 = 11001

Les deux premiers bits sont 1 dans les deux cas. Le nombre recherché commence donc par 1. Bien que le deuxième bit de 25 soit également 1, le deuxième bit de 18 est 0, ce qui explique pourquoi le troisième chiffre continue avec 0. Nous passons donc par les deux nombres bit par bit et obtenons fi­na­le­ment le nombre binaire 10000. Si nous le con­ver­tis­sons en nombre décimal, notre sortie est 16.

Le code ressemble à ceci :

public class Main {
	public static void main(String[] args) {
	System.out.println(18&25);
}
}

La sortie imprimée dans la console devrait main­te­nant être « 16 ».

OU bit à bit

L’opérateur Java Bitwise « OU bit à bit » compare également deux nombres bit par bit. Dans ce cas, un seul des deux opérandes doit cependant avoir la valeur 1 pour obtenir le résultat 1. Si nous reprenons les nombres 18 et 25 de l’exemple précédent, l’opération se présente comme suit :

18 = 10010 25 = 11001

Puisque tous les bits sauf le troisième chiffre con­tien­nent au moins un 1, ce troisième nombre en résulte : 11011. Nous obtenons ainsi 27 après con­ver­sion.

Voici le code cor­res­pon­dant :

public class Main {
	public static void main(String[] args) {
	System.out.println(18|25);
}
}

XOR

XOR ou l’opérateur « OU exclusif bit à bit » (^) est similaire à OU bit à bit. Alors qu’un ou les deux opérandes doivent être 1 pour cela, XOR ne sort un 1 que si exac­te­ment une des deux valeurs est également 1. Exemple :

18 = 10010 25 = 11001

Les deux premiers bits ayant une valeur de 1, Bitwise Operator in Java se traduit donc par 0. Le deuxième bit de 18 est 0, le deuxième bit de 25 est 1. Il en résulte une valeur de 1. Si nous pour­sui­vons, nous obtenons le troisième chiffre 01011. Dans sa forme décimale, il s’agit de 11.

Voici le code approprié :

public class Main {
	public static void main(String[] args) {
	System.out.println(18^25);
}
}

Décalage à gauche

Pour le décalage à gauche, déplacez les bits de la valeur a de la distance b vers la gauche. Les blancs ré­sul­tants sont remplis de 0. Ceci s’illustre par­fai­te­ment par une valeur int qui occupe 32 bits dans une mémoire. Reprenons pour le nombre a 20 ou 10010. Si nous décalons ceci de la valeur b 2, nous obtenons la valeur c 1001000. Donc deux zéros sont placés à la fin. 1001000 cor­res­pond à la valeur décimale 72.

Voici comment se présente cette opération dans le code :

public class Main {
	public static void main(String[] args) {
	int a = 20;
	int b = 2;
	int c = (a << b);
	System.out.println(c);
}
}

Décalage à droite avec signe

Le décalage vers la droite fonc­tionne exac­te­ment dans le sens inverse. Nous décalons ainsi les bits de la valeur a de la valeur b vers la droite et obtenons ainsi c. Les derniers bits sont omis. Dans notre exemple, si nous déplaçons le chiffre 20 ou 10010 de deux positions vers la droite, le résultat sera 100 ou 4.

Voici le code à essayer :

public class Main {
	public static void main(String[] args) {
	System.out.println(20 >> 2);
}
}

Il est important ici de noter que les blancs sont remplis avec 0 si a est un nombre positif. S’il est négatif, les blancs sont remplacés par 1.

Décalage à droite sans signe

L’opérateur Java Bitwise Décalage à droite sans signe (>>>) fonc­tionne en principe de la même manière. La seule dif­fé­rence est que les blancs créés à gauche par un décalage vers la droite sont toujours remplis de 0. Cela se traduit toujours par des nombres positifs à la fin, même si la valeur était pré­cé­dem­ment négative. f4155ea3ab2baef6c56bb528e812bf81