Manipulation de bits en

À propos de Manipulation de bits

Java dispose d'opérateurs pour manipuler les bits d'un type entier (un byte, short, int, long ou char).

Opérateurs de décalage

Utilise << pour décaler les bits vers la gauche et >> pour les décaler vers la droite.

// Shift two places to the left
0b0000_1011 << 2;
// # => 0b0010_1100

// Shift two places to the right
0b0000_1011 >> 2;
// # => 0b0000_0010

>> est aussi appelé opérateur de décalage signé ou décalage arithmétique, car le bit qu'il insère est identique à son bit de signe. Il s'agit du bit le plus à gauche : il vaut 0 si la valeur est positive et 1 si elle est négative. Un décalage vers la gauche avec << insère toujours des 0 du côté droit.

// Shift 2 places to the right preserves the sign
// The binary value is two's complement of 0b0000_0110 (or 0x00000026), so the binary representation will be
// 1000_0000_0000_0000_0000_0000_0010_0110
int value = -0x7FFFFFDA;

// Shift two places to the right, preserving the sign bit
value >> 2;
// # => 1110_0000_0000_0000_0000_0000_0000_1001

Utilise plutôt >>> quand des 0 doivent être insérés lors d'un décalage vers la droite. Le fait d'insérer des 0 lors d'un décalage est aussi appelé décalage logique.

// Shift two places to the right, inserting 0s on the left
value >>> 2;
// # => 0010_0000_0000_0000_0000_0000_0000_1001

Opérations bit à bit

ET bit à bit

L'opérateur ET bit à bit (&) prend deux valeurs et effectue un ET sur chaque bit. Il compare chaque bit de la première valeur au bit situé à la même position dans la seconde valeur. Si les deux valent 1, le bit du résultat vaut 1. Sinon, le bit du résultat vaut 0.

0b0110_0101 & 0b0011_1100;
// # => 0b0010_0100

OU bit à bit

L'opérateur OU bit à bit (|) prend deux valeurs et effectue un OU sur chaque bit. Il compare chaque bit de la première valeur au bit situé à la même position dans la seconde valeur. Si l'un des deux vaut 1, le bit du résultat vaut 1. Sinon, il vaut 0.

0b0110_0101 | 0b0011_1100;
// # => 0b0111_1101

OU exclusif bit à bit

L'opérateur OU exclusif bit à bit (^) effectue un OU exclusif bit à bit sur deux valeurs. Comme les opérateurs ET et OU bit à bit, il compare chaque bit de la première valeur au bit situé à la même position dans la seconde valeur. Si un seul des deux vaut 1, le bit résultant vaut 1. Sinon, il vaut 0.

0b0110_0101 ^ 0b0011_1100;
// # => 0b0101_1001

NON bit à bit (~)

Enfin, l'opérateur NON bit à bit (~) inverse chaque bit. Contrairement aux opérateurs précédents, il s'agit d'un opérateur unaire, qui n'agit que sur une seule valeur.

~0b0110_0101;
// # => 0b1001_1010