Manipulación de bits en

Acerca de Manipulación de bits

Java tiene operadores para manipular los bits de un tipo integral (un byte, short, int, long o char).

Operadores de desplazamiento

Usa << para desplazar bits a la izquierda y >> para desplazar a la derecha.

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

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

>> también se llama operador de desplazamiento con signo o desplazamiento aritmético porque el bit que inserta es el mismo que su bit de signo. Este es el bit más a la izquierda y es 0 si el valor es positivo o 1 cuando es negativo. Desplazar a la izquierda con << siempre inserta ceros en el lado derecho.

// 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 >>> en su lugar cuando se deban insertar ceros al desplazar a la derecha. Insertar ceros al desplazar también se conoce como desplazamiento lógico.

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

Operaciones bit a bit

AND bit a bit

El operador AND bit a bit (&) toma dos valores y realiza una operación AND en cada bit. Compara cada bit del primer valor con el bit en la misma posición del segundo valor. Si ambos son 1, el bit del resultado es 1. De lo contrario, el bit del resultado es 0.

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

OR bit a bit

El operador OR bit a bit (|) toma dos valores y realiza una operación OR en cada bit. Compara cada bit del primer valor con el bit en la misma posición del segundo valor. Si cualquiera de los dos bits es 1, el bit del resultado es 1. De lo contrario, es 0.

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

XOR bit a bit

El operador XOR bit a bit (^) realiza una operación XOR bit a bit sobre dos valores. Al igual que los operadores AND bit a bit y OR bit a bit, compara cada bit del primer valor con el bit en la misma posición del segundo valor. Si solo uno de ellos es 1, el bit resultante es 1. De lo contrario, es 0.

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

NOT bit a bit (~)

Por último, el operador NOT bit a bit (~) invierte cada bit. A diferencia de los operadores anteriores, este es un operador unario, que actúa solo sobre un valor.

~0b0110_0101;
// # => 0b1001_1010