Introduction aux opérations sur bits et aux scénarios d'application en Java

Nous savons que tous les nombres du programme sont stockés sous forme binaire dans la mémoire de l'ordinateur, et que les opérations sur les bits doivent opérer directement sur les bits binaires des entiers en mémoire. Par exemple, l'opération et est à l'origine un opérateur logique, mais l'opération ET peut également être effectuée entre des nombres entiers.

Les opérations sur les bits comprennent principalement les opérations de décalage et les opérations logiques. Nous parlerons ensuite respectivement des opérations de décalage et des opérations logiques.

Opération de décalage :

Décalage à gauche : L'opérateur est <<, déplacez-vous vers la gauche, ajoutez 0 au bit bas à droite, supprimez le bit haut à gauche, traitez binaire sous forme d'entier, un décalage vers la gauche de 1 bit équivaut à une multiplication par 2. Décalage à droite non signé : l'opérateur est >>>, se déplaçant vers la droite, supprimant le côté droit et ajoutant 0 au côté gauche. Décalage à droite signé : l'opérateur est >>, déplacez-vous vers la droite et supprimez le côté droit. La valeur ajoutée à gauche dépend du bit le plus élevé d'origine. S'il est à l'origine 1, ajoutez 1 et s'il est 0. , ajoutez 0. Pensez au binaire comme pour un entier, le décaler vers la droite de 1 bit équivaut à diviser par 2.

Par exemple :

int a = 4; // 100
a = a >> 2; // 001，等于1
a = a << 3 // 1000，变为8

Les opérations logiques incluent :

• AND& au niveau du bit : les deux bits sont 1 pour être 1

• OU au niveau du bit| : Tant qu'un bit est égal à 1, il est 1

• Négation au niveau du bit~ : 1 devient 0, 0 devient 1

• XOR au niveau du bit^ : différent est vrai, pareil est faux

Par exemple :

int a = ...; 
a = a & 0x1 // 返回0或1，就是a最右边一位的值。
a = a | 0x1 //不管a原来最右边一位是什么，都将设为1

Regardons quelques scénarios d'application simples :

Scénario 1 : Détermination de la parité

Analyse : Les nombres impairs ne sont pas des multiples entiers de 2. Après conversion en binaire, le bit le plus bas doit être 1, et l'inverse est vrai pour les nombres pairs. Grâce à cette fonctionnalité, nous pouvons facilement déterminer la parité d'un entier grâce à des opérations sur les bits.

Regardez le code :

   int i = 1;// 二进制存储方式为00000000000000000000000000000001
    int j = 5;// 二进制存储方式为00000000000000000000000000000101
    int k = 6;// 二进制存储方式为00000000000000000000000000000110
    if ((i & j) == 1) {
      System.out.println("j的最低位为1，为奇数");
    }    if ((i & k) == 0) {
      System.out.println("k的最低位为0，为偶数");
    }

Scénario 2 : Déterminer si un entier positif est une puissance entière de 2

Analyse : Examinons d'abord les puissances entières courantes de 2 Les nombres : 2, 4, 8, 16, convertis en binaire : 10, 100, 1000, 10000, avez-vous trouvé la régularité ? Autrement dit, à l’exception du premier bit qui vaut 1, les autres sont tous 0. Il se trouve qu’après avoir soustrait 1 de ces nombres, ils sont égaux aux résultats de leurs inversions au niveau du bit. Par exemple, 8-1=7, qui est 111 en binaire, peut être obtenu en inversant au niveau du bit le 1000 binaire de 8. Et 8&7=0, extrayez la règle et c'est :

(n&(n-1))==0

n qui est conforme à cette règle est une puissance entière de 2.

(Partage vidéo d'apprentissage : Tutoriel vidéo Java)

Scénario 3 : Traitement de collecte simple

Pas de bêtises, il suffit de regarder le code :

public class SimpleSet {  public static final int A = 0x01;// 最后四位为0001
  public static final int B = 0x02;// 最后四位为0010
  public static final int C = 0x04;// 最后四位为0100
  public static final int D = 0x08;// 最后四位为1000
  private int set = 0x00;// 初始0000，空集合
  public void add(int i) {// 将i对应位的值置为1，重复add不影响。默认传入值为ABCD之一，此处省去边界判断
    set |= i;
  }  public boolean contain(int i) {// 判断相应位置是否为1
    return (set & i) == i;
  }  public boolean remove(int i) {// 来不及不解释了快看代码
    if (contain(i)) {
      set -= i;      return true;
    } else {      return false;
    }
  }
}

Testez-le :

 public static void main(String[] args) {
    SimpleSet set = new SimpleSet();
    System.out.println(set.contain(A));
    set.add(B);
    System.out.println(set.contain(A));
    System.out.println(set.contain(B));
    set.add(A);
    set.add(C);
    System.out.println(set.contain(A));
    set.remove(A);
    System.out.println(set.contain(A));
    System.out.println(set.remove(A));
    System.out.println(set.contain(C));
  }

Le résultat est :

false
false
true
true
false
false
true

D'accord, pas de problème.

Vous pensez peut-être que A, B, C et D dans l'exemple de code ci-dessus sont quelque peu similaires aux énumérations. En fait, la classe de collection EnumSet dans le code source du jdk pour les énumérations utilise bien sûr une solution similaire. c'est beaucoup plus compliqué que cela. Si vous êtes intéressé, vous pouvez consulter le code source. Cette solution a un nom, appelé bit vector.

Au fait, il existe de nombreux outils statiques dans Integer, la classe d'empaquetage de int en Java, pour fournir des opérations sur les bits, et la plupart d'entre eux sont très compliqués. Si vous êtes intéressé, vous pouvez y jeter un œil <.>

Conclusion :

Les opérations au niveau du bit sont les opérations pour lesquelles les ordinateurs sont les meilleurs. Elles sont également largement utilisées dans le code source de jdk. Le comprendre nous aidera à comprendre plus profondément l'ordinateur et à écrire. code plus élégant.

Recommandations associées :

Tutoriel d'introduction à Java

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!