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 desplazarlos 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 denomina 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 vale 0 si el valor es positivo, o 1 si 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

En su lugar, usa >>> cuando haya que 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 a nivel de bits

AND a nivel de bits

El operador AND a nivel de bits (&) toma dos valores y realiza una operación AND sobre cada bit. Compara cada bit del primer valor con el bit que ocupa la misma posición en el segundo valor. Si ambos son 1, el bit del resultado es 1. En caso contrario, el bit del resultado es 0.

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

OR a nivel de bits

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

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

XOR a nivel de bits

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

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

NOT a nivel de bits (~)

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

~0b0110_0101;
// # => 0b1001_1010