Java Bitwise : vue d’ensemble des opérateurs et leur fonction

Avec Java Bitwise, vous pouvez manipuler des bits individuels à loisir. Les sept opérateurs au total sont toujours très similaires et suivent des règles précises faciles à assimiler.

Que sont les opérateurs bit à bit et à quoi servent-ils ?

Les opérateurs Java sont un outil essentiel pour manipuler le langage de programmation. Outre leurs nombreuses autres capacités et fonctions, ils vous offrent la possibilité de manipuler les plus petites unités d’information possibles. Ces bits (binary digits) ont leur propre système de numération basé sur les valeurs 0 et 1. Si vous voulez maintenant interroger les valeurs binaires bit par bit, vous avez besoin d’un Bitwise operator en Java. Vous pouvez appliquer cela aux types de données numé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’occurrence, si vous voulez économiser de l’espace lors de la conversion 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érations de commutation plus avancées. Il est donc utile de se pencher sur le fonctionnement fondamental de Java Bitwise.

Hébergement Web

Hébergement Web flexible, performant et sûr

• Certificat SSL et protection DDoS
• Sauvegarde et restauration des données
• Assistance 24/7 et conseiller personnel

Voir les packs

Quels sont les opérateurs Java Bitwise ?

Il existe un total de sept différents « Bitwise Operators in Java ». Pour une meilleure compréhension, nous partons des deux opérandes « a » et « b ».

• ~ (complé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, arithmé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 représenté par un tilde (~). Il change tous les bits en leurs opposés et transforme 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 maintenant 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’expression « ~20 ». Si nous convertissons 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 correctement, la sortie doit maintenant 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 correspondance 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 correspond à 10010 en tant que nombre binaire. Le 25 donne 11001 en notation binaire. Nous comparons maintenant 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 finalement le nombre binaire 10000. Si nous le convertissons 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 maintenant ê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 contiennent au moins un 1, ce troisième nombre en résulte : 11011. Nous obtenons ainsi 27 après conversion.

Voici le code correspondant :

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 exactement 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 poursuivons, 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ésultants sont remplis de 0. Ceci s’illustre parfaitement 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 correspond à 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 fonctionne exactement 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 (>>>) fonctionne en principe de la même manière. La seule diffé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édemment négative.