Manipolazione di bit in

Informazioni su Manipolazione di bit

Java ha degli operatori per manipolare i bit di un tipo integrale (un byte, short, int, long o char).

Operatori di shift

Usa << per spostare i bit a sinistra e >> per spostarli a destra.

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

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

L'operatore >> è anche chiamato shift con segno o shift aritmetico perché il bit che inserisce è uguale al suo bit di segno. Questo è il bit più a sinistra ed è 0 se il valore è positivo o 1 se è negativo. Lo shift verso sinistra con << inserisce sempre degli 0 sul lato destro.

// 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

Usa invece >>> quando si devono inserire degli 0 spostando verso destra. Inserire degli 0 durante lo shift è anche noto come shift logico.

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

Operazioni bit a bit

AND bit a bit

L'operatore AND bit a bit (&) prende due valori ed esegue un AND su ogni bit. Confronta ogni bit del primo valore con il bit nella stessa posizione del secondo valore. Se sono entrambi 1, il bit del risultato è 1. Altrimenti, il bit del risultato è 0.

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

OR bit a bit

L'operatore OR bit a bit (|) prende due valori ed esegue un OR su ogni bit. Confronta ogni bit del primo valore con il bit nella stessa posizione del secondo valore. Se uno dei due bit è 1, il bit del risultato è 1. Altrimenti, è 0.

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

XOR bit a bit

L'operatore XOR bit a bit (^) esegue un XOR bit a bit su due valori. Come gli operatori AND e OR bit a bit, confronta ogni bit del primo valore con il bit nella stessa posizione del secondo valore. Se solo uno dei due è 1, il bit risultante è 1. Altrimenti, è 0.

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

NOT bit a bit (~)

Infine, l'operatore NOT bit a bit (~) inverte ogni bit. A differenza degli operatori precedenti, questo è un operatore unario, che agisce su un solo valore.

~0b0110_0101;
// # => 0b1001_1010