Manipulação de Bits em

Sobre Manipulação de Bits

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

Operadores de deslocamento

Usa << para deslocar 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

O >> também é chamado de operador de deslocamento com sinal ou deslocamento aritmético porque o bit que insere é igual ao seu bit de sinal. Este é o bit mais à esquerda e é 0 se o valor for positivo ou 1 se for negativo. Deslocar para a esquerda com << insere sempre zeros 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

Usa >>> em vez disso quando forem inseridos zeros ao deslocar para a direita. Inserir zeros 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 realiza um AND em cada bit. Compara cada bit do primeiro valor com o bit na mesma posição do segundo valor. Se ambos 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 realiza um OR em cada bit. Compara cada bit do primeiro valor com o bit na mesma posição do segundo valor. Se um dos bits 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 (^) realiza um XOR bit a bit em dois valores. Tal como os operadores AND bit a bit e OR bit a bit, 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. Ao contrário dos operadores anteriores, este é um operador unário, que atua apenas sobre um valor.

~0b0110_0101;
// # => 0b1001_1010