Opérateurs bitwise en Java | Expliqué
Comment fonctionnent les opérateurs bitwise en Java
Cette section présente la syntaxe et le fonctionnement de chaque opérateur bitwise en Java.
Bitwise et (&): Cet opérateur est lié à la logique et au fonctionnement de Java. Cependant, l'opérateur et l'opérateur comparent les bits d'opérands et les rendements 1 si les deux nombres ont 1 au même endroit. Si les bits au même endroit ont autre que la combinaison 1,1, alors il remplacera 0 dans le bit résultant. La syntaxe fournie ci-dessous aide à appliquer le bit et le fonctionnement en Java.
Operand1 & Operand2;Bitwise ou (|): Cet opérateur compare les morceaux d'opérands et les rendements 1 si les opérandes ont un autre que 0,0 bits en place. Le bit ou est pratiqué à l'aide de la syntaxe suivante:
Operand1 | opérand2;Xor bit (^): Cela fonctionne différemment du dans le sens bit. Il renvoie 1 si les deux opérandes ont des bits différents et qu'il renvoie 0 dans le cas des mêmes bits d'opérands. La syntaxe suivante doit être suivie pour exercer le XOR sur le sens bit:
opérand1 ^ opérand2;Complément bitwise (~): Complément bitwise (~). Cela fait référence à la modification des bits d'un nombre de 0 à 1 et 1 à 0. La syntaxe fournie ci-dessous doit être suivie pour appliquer l'opérateur de complément de bit:
~ opérande;Note: Le compilateur Java prend le complément 2 pour utiliser l'opérateur de complément bitwise.
Opérateur de changement de vitesse gauche (<<): Cet opérateur déplace le bit de nombre vers la gauche par un numéro spécifique. La syntaxe suivante doit être suivie pour appliquer l'opérateur de changement de gauche:
opérande1<Bitwisedwised inning Dright Shift (>>>): Cela fait également référence au déplacement vers la droite en occupant l'espace vacant avec «0". La syntaxe fournie ci-dessous peut être utilisée pour appliquer l'opérateur non signé dans le sens bit:
opérand1 >> opérand2;Tout en traitant des opérateurs de quart de travail, il est recommandé que l'opérand2 soit inférieur à l'opérande1, sinon, une erreur peut être renvoyée. De plus, les nombres négatifs ne peuvent pas être utilisés pour appliquer les opérateurs de décalage comme le résultat pourrait être l'infini.
Comment utiliser les opérateurs de bitwise en Java
Cette section fournit la mise en œuvre de plusieurs opérateurs de bit sur Java.
En utilisant le bit ou (|): Le code Java écrit ci-dessous est pratiqué en utilisant le bit ou l'opérateur.
Package NewPack;classe publique bitwiseop
public static void main (String [] args)
// Initialisation des variables
int a = 4, b = 6;
// Impression du binaire de la variable A
Système.dehors.println (entier.tobinarystring (a));
// Impression du binaire de la variable b
Système.dehors.println (entier.tobinarystring (b));
// en utilisant l'opérateur OR sur A et B
Système.dehors.println ("Le résultat d'un | bis:" + (a | b));
// Impression du binaire de a | b
Système.dehors.println (entier.tobinarystring (a | b));
La description du code est:
- Initialisation de deux variables un et b
- Impression des binaires des variables, un et b
- imprime le résultat de A | B
- obtient le binaire de A | B
Note: Impression / obtenir le binaire de l'entier dans le code ci-dessus est facultatif. Nous l'avons utilisé pour une meilleure compréhension, sinon, Java effectue automatiquement les opérations de bit sur le binaire équivalent du nombre.
La sortie du code est fournie ci-dessous:
La sortie montre que les nombres binaires de «a = 4» et «b = 6" sont respectivement «100» et «110». Et lorsque l'opérateur «ou» est appliqué, le résultat est 6 et son binaire équivalent est «110».
En utilisant le bit et (&): Pour démontrer l'utilisation de Bitwise et, nous avons pratiqué le code Java suivant.
Package NewPack;classe publique bitwiseop
public static void main (String [] args)
// Initialisation des variables
int x = 5, y = 7;
// Impression du binaire de la variable x
Système.dehors.println (entier.tobinarystring (x));
// Impression du binaire de la variable y
Système.dehors.println (entier.tobinarystring (y));
// en utilisant l'opérateur sur x et y
Système.dehors.println ("Le résultat de x & y est:" + (x & y));
// Impression du binaire de X & Y
Système.dehors.println (entier.Tobinarystring (x & y));
Le code indiqué ci-dessus est décrit comme:
- initialise deux variables X et y
- imprimer le binaire de X
- imprimer le binaire de y
- application & opérateur sur X,y
- imprimé le binaire de x & y
La sortie du code ci-dessus est illustrée ci-dessous:
À partir de la sortie, il est observé que le binaire de «x = 5» et «y = 7» est respectivement «101» et «111». Quand ET est appliqué à ce sujet, le résultat est «5» qui a une valeur binaire «101».
Utilisation du complément bit (~): L'opérateur de complément bitwise est utilisé dans le code fourni.
Package NewPack;classe publique bitwiseop
public static void main (String [] args)
// Initialisation de la variable
int z = 2;
// en utilisant l'opérateur ~ sur z
Système.dehors.println ("Le résultat de ~ z est:" + ~ z);
Le code ci-dessus obtient la valeur de z = 2 et imprime le complément de bit z.
La sortie peut être vue ci-dessous:
En utilisant le changement de gauche bit (<<): Nous avons pratiqué le code Java suivant pour implémenter l'opérateur de quart de bit.
Package NewPack;classe publique bitwiseop
public static void main (String [] args)
// Initialisation de la variable
int a = 4;
// binaire d'un
Système.dehors.println (entier.tobinarystring (a));
// en utilisant le décalage gauche à gauche sur un
Système.dehors.println (un<<2);
// binaire d'un<<2
Système.dehors.println (entier.Tobinarystring (un<<2));
Le code ci-dessus est décrit ci-dessous:
- un la variable est initialisée
- imprimé le binaire de un
- Utiliser l'opérateur de changement de bit un
- Obtenir le binaire de un<<2 (Nombre de bits qui seront décalés)
La sortie du code est indiquée ci-dessous:
De la sortie, il est observé que le binaire de «a = 4» est «100» et lorsque 2bits sont décalés, le binaire serait «10000» et sa décimale équivalente serait «16».
Utilisation de Bitwise Right Shift (>>): L'applicabilité de l'opérateur de shift droit est décrite dans le code suivant.
Package NewPack;classe publique bitwiseop
public static void main (String [] args)
// Initialisation de la variable
int a = 7;
// binaire d'un
Système.dehors.println (entier.tobinarystring (a));
// en utilisant le changement de droite bitwise sur un
Système.dehors.println (a >> 2);
// binaire d'un >> 2
Système.dehors.println (entier.tobinarystring (a >> 2));
Le code est décrit comme:
- variable un est initialisé
- binaire de un est imprimé
- Appliqué à droite Shift on un
- imprimé le binaire de A >> 2.
La sortie du code est fournie ici:
La sortie montre que les 2bits droits sont retirés de «111» (binaire de 7) et que le binaire résultant est «1».
Utilisation de Bitwise Unssigned Right Shift (>>>): Le code suivant montre l'utilisation de l'opérateur de shift à droite non signé bitwise.
Package NewPack;classe publique bitwiseop
public static void main (String [] args)
// Initialisation de la variable
int x = 11;
// binaire de x
Système.dehors.println (entier.tobinarystring (x));
// Utilisation du changement de droite non signé bit sur x
Système.dehors.println (x >>> 2);
// binaire de x >>> 2
Système.dehors.println (entier.tobinarystring (x >>> 2));
La description du code est comme:
- initialisé une variable X
- imprimé le binaire de X
- imprimé le résultat de x >>> 2
- obtenu le binaire de x >>> 2
La sortie peut être vue dans l'image suivante:
L'opérateur de shift à droite non signé déplace le bit vers la droite et l'espace vacant est occupé par 2 (car nous avons réglé le nombre de bits sur 2) 0. De plus, il est observé à partir de la sortie que les 2bits les plus à droite sont supprimés.
Conclusion
Les opérateurs de bitwise de Java sont pratiqués en effectuant plusieurs opérations sur des modèles bit. Le modèle bitwise considère les bits pour manipuler les données. Cet article démontre plusieurs opérateurs de bitwise en Java. Les opérateurs de bitwise incluent le bit et le complément bit dans le sens bit. Vous auriez appris le travail et l'utilisation de base de tous ces opérateurs de bit sur Java.