Explication détaillée des opérations binaires Java (disposition des nœuds de puissance)

Cet article vous présente les techniques d'opération binaires Java, y compris les décalages, les opérations sur les bitsopérateurs et d'autres points de connaissances connexes. C'est très bien. Les amis intéressés peuvent s'y référer. .

Shift

La plupart des opérations dans les opérations sur bits sont le décalage à gauche et le décalage à droite. En Java, cela correspond aux deux opérateurs >. Les exemples sont les suivants :

/* 00000001 << 1 = 00000010 */
1 << 1 == 2 
/* 00000001 << 3 = 00001000 */
1 << 3 == 8
/* 11111111 11111111 11111111 11110000 >> 4 = 11111111 11111111 11111111 11111111 */
0xFFFFFFF0 >> 4 == 0xFFFFFFFF 
/* 00001111 11111111 11111111 11111111 >> 4 = 00000000 11111111 11111111 11111111 */
0x0FFFFFFF >> 4 == 0x00FFFFFF

Remarque : le déplacement vers la droite est un opérateur signé. Comme beaucoup de langages, Java utilise le bit le plus élevé pour représenter les valeurs positives et négatives, et le bit le plus élevé des nombres négatifs est toujours 1. Un nombre binaire commençant par 1 commencera également par 1 après le décalage, et un arbre binaire commençant par 0 commencera toujours par 0 après le décalage. Soyez donc prudent : Java peut effectuer des opérations au niveau du bit sur des entiers.

Vous pouvez utiliser le troisième opérateur appelé "décalage à droite non signé" opérateur : >>> pour implémenter un décalage rempli de bit "0", ce décalage ignore le signe le bit et le remplit toujours avec "0".

/* 10000000 00000000 00000000 00000000 >>> 1 = 01000000 00000000 00000000 00000000 */
0x80000000 >>> 1 == 0x40000000
/* 10000000 00000000 00000000 00000000 >> 1 = 11000000 00000000 00000000 00000000 */
0x80000000 >> 1 == 0xC0000000

L'une des plus grandes utilisations est de trouver rapidement des puissances de 2. Décaler 1 vers la gauche d'1 bit vaut 2, décaler 2 bits vaut 4, décaler 3 bits vaut 8... De même, décaler 1 bit vers la droite équivaut à diviser le nombre par 2.

Une autre utilisation est de créer des masques. Les masques de bits peuvent être utilisés pour masquer ou modifier certains bits spécifiés dans un nombre binaire, ce qui sera expliqué en détail dans la section suivante. Si l'on veut créer un masque de

00001000, le code est très simple :

int bitmask = 1 << 3;

Vous pouvez utiliser des opérateurs au niveau du bit pour créer des masques plus complexes, comme cela sera expliqué dans la section suivante Opérateurs au niveau du bit.

Opérateurs d'opérations au niveau du bit

Voici quatre opérateurs au niveau du bit courants en Java :

•  ~ – Négation au niveau du bit

•  & – AND au niveau du bit

•  ~ – XOR au niveau du bit

•  | – OU au niveau du bit

•  L'application simple est la suivante (pour plus de simplicité, seul le binaire est affiché)

1010 & 0101 == 0000
1100 & 0110 == 0100
1010 | 0101 == 1111
1100 | 0110 == 1110
~1111 == 0000
~0011 == 1100
1010 ^ 0101 == 1111
1100 ^ 0110 == 1010

Par exemple, vous pouvez "mettre" un bit spécifié sur un nombre binaire à 1 via l'opération "OU" sans affecter les autres bits.

10000001 | 00100000 = 10100001 /* 第五位设为1 */
10000001 | 1 << 5 = 10100001 /* 同样作用 */
00000000 | 1 << 2 | 1 << 5 = 00100100

Si vous souhaitez définir sélectivement un certain bit sur 0, vous pouvez ET le nombre avec un nombre qui n'a que des 1 mais un certain bit est 0.

01010101 & ~(1<<2) == 01010101 & 11111011 == 01010001

À propos de l'ordre des bits

En supposant que le bit le plus élevé est à gauche :

10010110
^   ^
|   |------- 第 0 位
|
|-------------- 第 7 位

Notez que le 0ème La valeur du bit est 2^0, le premier bit est 2^1,..., la valeur du 7ème bit est 2^7.

Utilisation de ParseInt

Un moyen pratique de manipuler les nombres binaires dans votre code consiste à utiliser la méthode Integer.parseInt(). Integer.parseInt("101″,2) représente la conversion du nombre binaire 101 en nombre décimal (5). Cela signifie qu'avec cette méthode, vous pouvez même utiliser des nombres binaires dans une boucle for :

/* 从5到15的循环 */
for (int b = Integer.parseInt("0101",2); b <= Integer.parseInt("1111",2); b++) {
  /* 做些什么 */
}

lecture et écriture de bits

Suggestion : implémentez une classe qui convertit les bits binaires (bits) en flux et les lit et les écrit. Essayez de ne pas utiliser les flux d'entrée et de sortie de Java, car les flux de Java ne peuvent fonctionner que sur des octets. Vous trouverez les fonctions « donnez-moi les N bits suivants » et « avancez le pointeur de M bits » très utiles. Par exemple, vous pouvez lire suffisamment de données pour déterminer la longueur du code de Huffman le plus long. Lorsque vous obtenez la longueur réelle du code de Huffman que vous venez de lire, vous pouvez avancer le pointeur de la longueur correspondante. Une telle classe peut diviser le côté laid des opérations sur les bits en un bloc de code familier.

De même, si vous recherchez la vitesse, vous découvrirez de manière inattendue que la recherche de table est si puissante. Si vous avez un code Huffman commençant par 0 et que les autres codes sont tous de longueur 3 et commencent par 1, cela signifie que vous avez besoin d'une table pouvant contenir 8 (2^3) éléments. Votre table peut ressembler à comme ceci :

char code[8];
int codelen[8];
code[0] = 'a'; codelen[0] = 1;
code[1] = 'a'; codelen[1] = 1;
code[2] = 'a'; codelen[2] = 1;
code[3] = 'a'; codelen[3] = 1;
code[4] = 'b'; codelen[4] = 3;
code[5] = 'c'; codelen[5] = 3;
code[6] = 'd'; codelen[6] = 3;
code[7] = 'e'; codelen[7] = 3;

En cherchant deux fois, vous pouvez localiser le personnage que vous recherchez, et vous pouvez également savoir à quelle distance se trouve le personnage suivant. C'est beaucoup plus rentable que de boucler encore et encore pour trouver tous les caractères, et cela permet d'économiser plus de mémoire.

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!