Manipulação de bits em

Sobre Manipulação de bits

Java tem operadores para manipular os bits de um tipo integral (um byte, short, int, long ou char).

Operadores de deslocamento

Use << para deslocar os bits para a esquerda e >> para deslocar para a direita.

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

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

>> também é chamado de operador de deslocamento com sinal ou deslocamento aritmético porque o bit que ele insere é o mesmo que o seu bit de sinal. Esse é o bit mais à esquerda e vale 0 se o valor for positivo ou 1 se for negativo. Deslocar para a esquerda com << sempre insere 0s do lado direito.

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

Use >>> quando quiser inserir 0s ao deslocar para a direita. Inserir 0s ao deslocar também é conhecido como deslocamento lógico.

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

Operações bit a bit

AND bit a bit

O operador AND bit a bit (&) recebe dois valores e faz um AND em cada bit. Ele compara cada bit do primeiro valor com o bit na mesma posição do segundo valor. Se os dois forem 1, o bit do resultado é 1. Caso contrário, o bit do resultado é 0.

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

OR bit a bit

O operador OR bit a bit (|) recebe dois valores e faz um OR em cada bit. Ele compara cada bit do primeiro valor com o bit na mesma posição do segundo valor. Se um dos dois for 1, o bit do resultado é 1. Caso contrário, é 0.

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

XOR bit a bit

O operador XOR bit a bit (^) faz um XOR bit a bit em dois valores. Assim como os operadores AND bit a bit e OR bit a bit, ele compara cada bit do primeiro valor com o bit na mesma posição do segundo valor. Se apenas um deles for 1, o bit resultante é 1. Caso contrário, é 0.

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

NOT bit a bit (~)

Por último, o operador NOT bit a bit (~) inverte cada bit. Diferente dos operadores anteriores, esse é um operador unário, que age sobre apenas um valor.

~0b0110_0101;
// # => 0b1001_1010