Introduction aux opérations sur bits Java (exemple de code)

Cet article vous présente une introduction aux opérations sur les bits Java (exemples de code). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Nous savons tous que dans le monde informatique, peu importe la complexité ou la beauté du programme, il finira par se transformer en 0 et en 1. C'est ce que nous appelons souvent : binaire. Je pense que tout le monde connaît le binaire. Ce qui est différent du monde réel, c'est que dans le monde réel, nous utilisons généralement le nombre décimal pour l'exprimer, c'est-à-dire que lorsque nous rencontrons dix contre un, ceux-ci nous sont tous familiers. À ce stade, nous trouverons des indices selon lesquels les unités de mesure décimales dans le monde réel et binaires dans les ordinateurs sont différentes. Alors comment convertir entre eux ? Cela implique des connaissances informatiques relativement basiques. Non abordé dans cet article (si vous êtes intéressé, vous pourrez en parler la prochaine fois). Eh bien, revenons au sujet d’aujourd’hui, parlons des opérations sur les bits. De quel genre de concept s’agit-il ? Nous avons été exposés aux opérations d'addition, de soustraction, de multiplication et de division dans le monde réel depuis l'enfance, qui sont des opérations dans le système décimal. Ce dont nous allons parler aujourd'hui, c'est de quelques opérations courantes sur les bits binaires. Par exemple : & (ET au niveau du bit), | (OU au niveau du bit), ^ (OU exclusif), <<(décalage à gauche), >>(décalage à droite), etc.

Vrai et Faux
Avant d'utiliser les opérateurs, il faut parler du vrai et du faux. En Java, nous savons tous que la valeur true représente vrai et la valeur false représente faux. En fait, dans les ordinateurs, 1 est généralement utilisé pour représenter vrai et 0 pour représenter faux. Les étudiants qui ont utilisé Json doivent savoir que le type booléen en Java peut également être désérialisé en vrai en utilisant 1, et que 0 peut être désérialisé en faux.

& (ET au niveau du bit)
Avant de parler du ET au niveau du bit, parlons d'abord de l'opération ET logique familière. Pour faire simple : A&&B signifie : c’est vrai quand A et B sont tous deux vrais, sinon c’est faux. Certains l'appellent aussi : « Une fois qu'un mensonge est faux, il doit être faux. »

Regardons maintenant la position et. Tout d'abord, regardons un programme :

@Test

public void testBit(){
    int a = 8;
    int b = 9;
    System.out.println("a binary: "+Integer.toBinaryString(a));
    System.out.println("b binary: "+Integer.toBinaryString(b));
    System.out.println("a & b binary: "+Integer.toBinaryString(a&b));
    System.out.println("a & b result: "+(a&b));
}

Avant de regarder l'explication, devinons quel est le résultat ?

Explication du code :

Bit AND : On le comprend littéralement, c'est aussi une opération AND de bits binaires.

La notation décimale du chiffre 8 est : 1000.

La forme décimale du nombre 9 est : 1001.

Effectuons à nouveau l'opération de localisation :

comme suit :

8：1000
9：1001
&
8 1000

Le 1&1 le plus à gauche = 1, le 0&0 du milieu = 0 et le 0&1 le plus à droite = 0.

Le résultat binaire est : 1000, soit 8 après conversion en décimal.

Le résultat de l'exécution du programme est le suivant :

a binaire : 1000
b binaire : 1001
a & b binaire : 1000
a & b résultat : 8

Les résultats sont comme prévu.

| (bit-or)

L'opération & (bit-and) mentionnée ci-dessus, jetons maintenant un coup d'œil à l'opération bit-or et continuons à l'utiliser l'exemple ci-dessus : comme indiqué ci-dessous :

@Test

public void testBit(){
    int a = 8;
    int b = 9;
    System.out.println("a binary: "+Integer.toBinaryString(a));
    System.out.println("b binary: "+Integer.toBinaryString(b));
    System.out.println("a & b binary: "+Integer.toBinaryString(a|b));
    System.out.println("a & b result: "+(a|b));
}

Regardez à nouveau le binaire :

8 : 1000
9 : 1001
|
9 1001
Le 1|1 le plus à gauche = 1, le 0|0 du milieu = 0 et le 0|1 le plus à droite = 1.

Le système binaire du résultat est : 1001 et le système décimal correspondant est 9.

Le résultat de l'opération est le suivant :

a binaire : 1000
b binaire : 1001
a & b binaire : 1001
a & b résultat : 9

^(XOR)

Cet opérateur est plus intéressant X signifie littéralement : différent. Il en va de même pour les opérations de placement. En continuant avec l'exemple ci-dessus :

@Test

public void testBit(){
    int a = 8;
    int b = 9;
    System.out.println("a binary: "+Integer.toBinaryString(a));
    System.out.println("b binary: "+Integer.toBinaryString(b));
    System.out.println("a & b binary: "+Integer.toBinaryString(a^b));
    System.out.println("a & b result: "+(a^b));
}

Continuez à regarder le binaire :

8:1000
9:1001
^
1 0001

est faux lorsque les bits sont identiques, et vrai lorsqu'ils sont différents. Le 1=1 à gauche est identique à faux, qui vaut 0. Le 0=0 au milieu est également faux et 0. Le 0 le plus à droite n’est pas égal à 1, ce qui est vrai. Le résultat est 1.

<<(Maj gauche)

Dans le monde réel, nous utilisons souvent la multiplication. << signifie une opération de déplacement en binaire, avec les bits faibles remplis de 0. Par exemple : 8<<1.

@Test

public void testCode(){
    int a =8;
    System.out.println("a toBinaryString: "+Integer.toBinaryString(a));
    System.out.println("a<<1 toBinaryString: "+Integer.toBinaryString(a<<1));
    System.out.println("result: "+(a<<1));

Le binaire est le suivant :

8 1000
8<<1
16 10000

Le résultat est : 2^4 = 16. << Le a à gauche représente la base et le 1 à droite représente le nombre de bits qui doivent être décalés. Quelle que soit la direction vers laquelle pointe la flèche, c'est là que se fera le déplacement. Résultat de l'exécution du programme :

a toBiryString : 1000
a<<1 toBinaryString : 10000
résultat : 16

>> 🎜>

(décalage à droite) est l'opposé du décalage à gauche <<, les bits hauts sont remplis de 0. En continuant avec l'exemple ci-dessus :

@Test

Binaire :

public void testCode(){
    int a =8;
    System.out.println("a toBinaryString: "+Integer.toBinaryString(a));
    System.out.println("1>>a toBinaryString: "+Integer.toBinaryString(a>>1));
    System.out.println("result: "+(a>>1)
}
8 : 1000
8>>1
4 : 0100 

Résultat d'exécution : 
a toBinaryString : 1000
a>>1 toBinaryString : 100
result: 4

En fait, il y en a un autre c'est plus facile à retenir La formule : 
a>>n signifie : a / (2^n) puissance. (Arrondi)
a<
Faisons maintenant un calcul rapide : 
Quand a = 13, n = 2. 13<<2 est égal à 13* 4 = 52. 13/4 = 3. 
(S'il y a des erreurs dans l'algorithme de vitesse ci-dessus, n'hésitez pas à me gifler !!!)

Les opérations de décalage au niveau des bits sont très courantes dans notre code source et nos algorithmes courants. Il est également nécessaire qu'un programmeur Java maîtrise les opérations au niveau des bits. Ceci est très utile pour notre compréhension de l’algorithme et du code source ! 

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!