En esta entrada vamos a adentrarnos en los operadores bitwise en Java, también llamados operadores a nivel del bits. Los operadores bitwise son un conjunto de operadores que trabajan bit a bit directamente sobre la representación binaria de los datos. En ocasiones también se les llama operadores de bajo nivel ya que operan directamente con los bits que forman los datos.

Aunque a primera vista pueden parecer poco útiles, los operadores bitwise son fundamentales para entender cómo se almacena y manipula la información en memoria y tienen aplicaciones reales en ámbitos como el tratamiento de colores, el uso de banderas u opciones, la optimización de cálculos y la programación de bajo nivel. A lo largo de la entrada veremos para qué sirve cada operador, cómo funciona exactamente y ejemplos de uso de cada uno de ellos.

Los operadores bitwise no suelen aparecer en programas básicos ni en programas avanzados de gestión. Los operadores bitwise en java se suelen usar en:

• Programación de bajo nivel
• Optimización de memoria
• Programación de sistemas
• Motores gráficos
• Drivers
• Compresión de datos
• Criptografía
• Tratamiento de permisos o estados

Solo se pueden utilizar con datos de tipo entero: byte, short, int, long, char.

Los operadores Java a nivel de bits se dividen en:

Operadores & | ^ ~

Los operadores bitwise en Java de tipo lógico se utilizan cuando el valor de un número entero no representa una cantidad, sino un conjunto de opciones.

Cada uno de los bits del número representa una opción, estado, característica, etc. que puede estar activada o no. Si el valor del bit es 0 significa que está desactivado. Si el valor del bit es 1 significa que está activado.

Ejemplo:

Vamos a crear una variable de tipo int llamada opciones. Esta variable la vamos a utilizar para almacenar el estado de una serie de opciones de un dispositivo. En concreto la vamos a utilizar para las opciones WiFi, Bluetooth, Modo avión y GPS.

Cada bit de la variable representará una de esas opciones. Si el bit vale 0 la opción está desactivada y si vale 1 está activada.

La opciones que corresponden a cada bit son estas:

Creamos la variable y le asignamos el valor binario 00001011.

int opciones = 0b00001011;

Los valores de los bits de la variable opciones son estos:

Los bits 0, 1, y 3 contienen el valor 1 indicando que esas opciones están activadas, el bit 2 contiene el valor 0 indicando que esa opción está desactivada:

Las variables de tipo int en Java ocupan 4 bytes (32 bits) por lo que en en realidad el contenido de la variable opciones habría que mostrarlo completando con ceros por la izquierda hasta llegar a los 32 bits. Por simplicidad aquí solo se muestran los 8 primeros bits de la derecha.

Utilizaremos la variable opciones de este ejemplo para explicar el funcionamiento de los operadores a nivel de bits lógicos.

Es el operador AND a nivel de bits. Realiza la operación AND entre los bits de dos valores numéricos.

El resultado de aplicar el operador & es 1 si ambos bits son 1. En cualquier otro caso el resultado es 0.

Resultado de aplicar el operador & entre bits
0 & 0 -> 0
0 & 1 -> 0
1 & 0 -> 0
1 & 1 -> 1

El operador & se suele usar para:

• Comprobar si una opción está activada
• Aplicar máscaras de bits

Ejemplo de uso del operador & a nivel de bits: comprobar el estado de una opción.

A partir de la variable opciones del ejemplo anterior, vamos a comprobar si el Bluetooth está activado.

El Bluetooth está representado por el bit 1 de la variable. Para comprobar si está activado o no, podemos escribir una instrucción & entre la variable opciones y el valor 00000010, es decir, hacemos la operación & entre opciones y un valor binario donde el bit 1 tiene el valor 1 y el resto de bits el valor 0.

if ((opciones & 0b00000010) != 0) {
    System.out.println("Bluetooth activado");
} else {
    System.out.println("Bluetooth desactivado");
}

Si el contenido de la variable opciones es 00001011 la operación opciones & 0b00000010 dará como resultado:

00001011 & 00000010 -> 00000010

El resultado es distinto de 0 por lo tanto el Bluetooth está activado.

Si el contenido de opciones hubiese sido por ejemplo 00001001, la operación opciones & 0b00000010 daría como resultado:

00001001 & 00000010 -> 00000000

En este caso el resultado es 0 por lo tanto el Bluetooth está desactivado.

Es el operador OR a nivel de bits. Realiza la operación OR entre los bits de dos valores numéricos.

El resultado de aplicar el operador OR entre bits es 0 si ambos bits tienen el valor 0. En cualquier otro caso el resultado es 1.

Resultado de aplicar el operador | entre bits
0 | 0 -> 0
0 | 1 -> 1
1 | 0 -> 1
1 | 1 -> 1

El operador | a nivel de bits se suele usar para activar una opción sin modificar las demás.

Ejemplo de uso del operador | a nivel de bits: activar una opción.

A partir de la variable opciones del ejemplo anterior, vamos a realizar la operación para activar el GPS.

Supongamos que la variable contiene el valor 00000011. Esto indica que WiFi (bit 0) y Bluetooth (bit 1) están activados y Modo avión (bit 2) y GPS (bit 3) están desactivados.

El GPS está representado por el bit 3 de la variable. Para activarlo podemos escribir una instrucción | entre la variable opciones y el valor 00001000, es decir, hacemos la operación | entre opciones y un valor binario donde el bit 3 tiene el valor 1 y el resto de bits el valor 0. El resultado de esta operación se asigna de nuevo a la variable opciones.

opciones = opciones | 0b00001000

Si el contenido de la variable opciones es 00000011, la instrucción opciones = opciones | 0b00001000 dará como resultado:

opciones = 00000011 | 00001000 -> opciones = 00001011

La operación | ha modificado el valor del bit 3 pasando a valer 1. El GPS está ahora activado.

Es el operador XOR, también llamado OR exclusivo, a nivel de bits. Realiza la operación XOR entre los bits de dos valores numéricos.

El resultado de aplicar el operador XOR entre bits es 0 si ambos bits son iguales y 1 si ambos bits son distintos.

Resultado de aplicar el operador ^ entre bits
0 ^ 0 -> 0
0 ^ 1 -> 1
1 ^ 0 -> 1
1 ^ 1 -> 0

El operador ^ se suele usar para cambiar el estado de una opción.

Ejemplo de uso del operador ^ a nivel de bits: modificar una opción.

A partir de la variable opciones del ejemplo anterior, vamos a modificar el estado del wifi. Si está activado se desactiva y si está desactivado se activa.

El wifi está representado por el bit 0 de la variable. Para cambiar su estado se escribe una instrucción ^ entre la variable opciones y el valor binario 00000001. En este valor, el bit 0 tiene el valor 1 y el resto de bits el valor 0. El resultado de esta operación se asigna de nuevo a la variable opciones.

opciones = opciones ^ 0b00000001

Si la variable opciones contiene por ejemplo el valor 00000011, la instrucción opciones = opciones ^ 0b00000001 dará como resultado:

opciones = 00000011 ^ 00000001 -> opciones = 00000010

Mediante la operación ^ se ha modificado el valor del bit 0 pasando de valer 1 a valer 0. El wifi ha cambiado de estado, pasando a estar desactivado.

El operador ~ también llamado operador complemento a 1 o operador NOT a nivel de bits, es un operador bitwise unario (operador a nivel de bits que afecta a un solo operando) cuya función es modificar el valor de los bits del número sobre el que se aplica.

El operador ~ modifica los bits de la siguiente forma:

• Los bits con valor 0 pasan a valer 1
• Los bits con valor 1 pasan a valer 0

El operador complemento a 1 se suele usar para crear máscaras de bits.

Ejemplo de uso del operador ~ a nivel de bits: crear una máscara de bits para desactivar una opción.

Supongamos que queremos desactivar el GPS.

El GPS está representado por el bit 3 de la variable opciones. Para desactivarlo, primero creamos una máscara con el valor 0b00001000 y le aplicamos el operador complemento a 1:

int mascara = ~0b00001000;

Al aplicar el operador ~ al valor binario 00001000 , el valor de los bits de la variable máscara será este:

11110111

A continuación se aplica el operador bitwise & con las variables opciones y mascara

Si la variable opciones contiene por ejemplo el valor 00001011, la instrucción opciones = opciones & mascara dará como resultado:

opciones = 00001011 & 11110111  -> opciones = 00000011

El valor del bit 3 ha cambiado de 1 a 0. El GPS se ha desactivado.

Operadores << >> >>>

Los operadores de desplazamiento se utilizan para realizar un desplazamiento de los bits del número hacia la derecha o hacia la izquierda. A continuación se explica en qué consiste cada uno de estos operadores de desplazamiento a nivel de bits en Java y para qué se usan.

El operador << es el operador desplazamiento a la izquierda.

Desplaza los bits del número hacia la izquierda la cantidad de lugares que se indique, rellenando con ceros por la derecha.

Ejemplo:

int x = 6; 

La variable x contiene el valor 6. En binario el valor 6 es

00000110

Aplicamos a la variable x el operador << para desplazar sus bits 1 lugar a la izquierda:

x = x << 1; 

al desplazar todos los bits de x 1 lugar a la izquierda su contenido ahora es este:

00001100

El valor binario 00001100 equivale a 12 en decimal

La variable x contiene ahora el valor 12.

Ejemplo:

int a = 12;   //valor binario de a:  00001100
a = a << 3; //se desplazan los bits 3 lugares a la izquierda rellenando con ceros por la derecha
System.out.println(a); //se muestra el valor de a: 96

al desplazar los bits de 3 lugares a la izquierda, ahora el valor de la variable a es este:

 01100000  ->  96 en decimal

Cada desplazamiento de bits a la izquierda equivale a una multiplicación por 2, por lo que la operación a << 3 equivale a realizar la operación a * 23

El signo de un número entero lo indica el bit más significativo. Para un número de tipo int el bit más significativo corresponde al bit en la posición 31. Los tipos int en Java ocupan 32 bits siendo el bit 0 (el de más a la derecha) el menos significativo y el bit 31 (el de más a la izquierda) el más significativo. Si el bit más significativo vale 0 el número es positivo. Si vale 1 el número es negativo.

Al desplazar los bits a la derecha es posible que podamos modificar el bit más significativo y por lo tanto el signo del número pueda cambiar.

Por ejemplo, supongamos que tenemos una variable x que contiene el valor 1610612736. A continuación realizamos sobre x un desplazamiento a la izquierda y mostramos el valor de x:

int x = 1610612736;
x = x << 1;
System.out.println("x  = " + x);

Se muestra por pantalla:

x = -1073741824

Se muestra un número negativo cuando lo esperado era que al realizar un desplazamiento a la izquierda el valor de x fuera el doble del que tenía.

La explicación es la siguiente: el valor inicial de la variable x es 1610612736 que en binario equivale a

01100000000000000000000000000000

Al desplazar los bits 1 lugar a la izquierda, el contenido de x ahora es este:

11000000000000000000000000000000

El bit de signo, bit 31 (el de la izquierda), ahora vale 1 por lo que el número que contiene la variable x es negativo.

En computación para representar los números negativos en binario se utiliza el sistema de representación complemento a 2.

Según la representación en complemento a 2, el equivalente en decimal de este número binario lo podemos calcular así:

2³¹ = 2147483648

2³⁰ = 1073741824

-2147483648 + 1073741824 = -1073741824

La explicación del complemento a 2 se nos queda fuera del objetivo de este tema. Si no sabes en qué consiste puedes ver una breve explicación en este video: expresar números negativos en binario. Complemento a 1 y a 2.

El operador >> es el operador desplazamiento a la derecha con signo.

Desplaza los bits del número hacia la derecha tantos lugares como se indique manteniendo el signo.

Los bits de la izquierda se rellenan de la siguiente forma:

• Se rellenan con ceros si el número es positivo
• Se rellenan con unos si el número es negativo

Ejemplo:

int x = 8;

La variable x contiene el valor 8. Las variables de tipo int en java ocupan 4 bytes (32 bits). El valor que contiene x en binario es:

00000000000000000000000000001000

Si realizamos un desplazamiento de bits un lugar a la derecha:

x = x >> 1;

El valor de x ahora es :

00000000000000000000000000000100

Ese valor binario equivale a 4 en decimal. La variable x contiene ahora el valor 4.

Ejemplo

int x = 15;      // x = 00000000000000000000000000001111
x = x >> 2;      // x = 00000000000000000000000000000011
System.out.println(x);  //muestra 3

La operación x >> 2 desplaza los bits de x dos lugares a la derecha. Como el número es positivo, se rellena con ceros por la izquierda.

El valor de la variable x ahora es 3.

Cada desplazamiento de bits a la derecha equivale a una división por 2, por lo que la operación x >> 2 equivale a realizar la operación x / 22

Ejemplo de desplazamiento de bits a la derecha con un número negativo:

int x = -8;     
x = x >> 2;   
System.out.println(x); //muestra -2

El número -8 en complemento a 2 es:

11111111111111111111111111111000

La operación x >> 2 desplaza los bits del número 2 lugares a la derecha. Como el número es negativo, los bits de la izquierda se rellenan con unos. Después del desplazamiento de bits, la variable x contiene:

11111111111111111111111111111110

que equivale al valor decimal -2

Es el operador de desplazamiento de bits a la derecha sin signo.

Desplaza los bits del número hacia la derecha tantos lugares como se indique sin mantener el signo. Los bits de la izquierda se rellenan con ceros por lo que el número puede pasar de negativo a positivo.

La diferencia entre los operadores Java de desplazamiento >> y >>> es que el operador >> mantiene el signo del número rellenando con 0 si el número es positivo o con 1 si el número en negativo mientras que el operador >>> no mantiene el signo del número ya que siempre rellena los bits de la izquierda con 0. Si el número es negativo pasará a ser positivo.

Ejemplo de desplazamiento de bits a la derecha sin signo con un número positivo:

int x = 20;           // x = 00000000000000000000000000010100
x = x >>> 1;          // x = 00000000000000000000000000001010
System.out.println(x);  //muestra 10

La operación x >>> 1 desplaza los bits de x un lugar a la derecha rellenando con 0 por la izquierda.

El valor de la variable x ahora es 10. Como el número es positivo, el resultado de esta operación es el mismo que si se hibuese realizado con el operador de desplazamiento a la derecha con signo >>

Ejemplo de desplazamiento de bits a la derecha sin signo con un número negativo:

int x = -20;     
x = x >>> 2;   
System.out.println(x); //muestra 1073741819

El número -20 en complemento a 2 es:

11111111111111111111111111101100

La operación x >>> 2 desplaza los bits del número 2 lugares a la derecha sin mantener el signo. Los bits de la izquierda se rellenan con ceros. Después del desplazamiento de bits, la variable x contiene:

00111111111111111111111111111011

El número ha pasado a ser positivo ya que el bit más significativo ahora vale 0. Equivale al valor decimal 1073741819

Entonces, si al aplicar el operador >>> un número que es negativo se puede convertir en otro número positivo sin una relación aparente con el número original ¿Qué sentido tiene usar el operador de desplazamiento a la derecha sin signo?

La respuesta es la siguiente:

Ejemplo práctico de uso del operador desplazamiento a la derecha sin signo: Extraer los componentes de un color ARGB almacenado en un entero.

En aplicaciones gráficas los componentes de un color no se almacenan en variables separadas sino que se empaquetan dentro de un único número entero.

Cada color se puede representar mediante el modelo ARGB, donde:

• A (Alpha) indica el nivel de transparencia
• R (Red) es el componente rojo
• G (Green) es el componente verde
• B (Blue) es el componente azul

Cada componente del color ocupa 1 byte (8 bits). El color completo se almacena en una variable de tipo int que en Java ocupa 4 bytes (32 bits)

Los componentes del color se guardan en la variable de la siguiente forma:

AAAA AAAA RRRR RRRR GGGG GGGG BBBB BBBB

De esta forma, el contenido de la variable no hay que verlo como un valor numérico sino que contiene 4 valores que representan los componentes de un color.

Supongamos que creamos la variable color de tipo int con este valor inicial para el color codificado en hexadecimal:

int color = 0xFF456585;

Este valor hexadecimal representa un color ARGB donde cada par de dígitos hexadecimales corresponde a un componente del color.

El contenido de la variable color es:

El objetivo de este ejemplo es obtener por separado los valores de los componentes Alpha, Red, Green, Blue y guardarlos en variables.

Lo que queremos conseguir es tener cuatro variables con los siguientes valores:

alpha = 0xFF
red = 0x45
green = 0x65
blue = 0x85 

Para obtener los componentes por separado utilizaremos el operador de desplazamiento de bits a la derecha sin signo >>> junto con el operador bitwise lógico &.

Para obtener el componente Alpha desplazaremos los bits de la variable color 24 posiciones a la derecha mediante el operador >>>

int alpha = color >>> 24;

Utilizando el operador >>> para desplazar los bits de color 24 posiciones a la derecha conseguimos que los bits de relleno por la izquierda sean ceros.

El contenido de la variable alpha es:

0000 0000 0000 0000 0000 0000 1111 1111 

que en hexadecimal equivale al valor:

0xFF

Para obtener el componente Red lo haremos con dos operaciones:

Primero realizamos un desplazamiento de los bits de color 16 posiciones a la derecha con el operador >>> y a continuación aplicamos a ese resultado un & con el valor 0xFF.

int red   = (color >>> 16) & 0xFF;

La operación color >>> 16 realiza un desplazamiento de los bits de color 16 posiciones a la derecha rellenando con ceros por la izquierda.

0000 0000 0000 0000 1111 1111 0100 0101 

A continuación, la operación & 0xFF pone todos los bits a cero excepto los dos últimos bytes que son los que contienen el valor correspondiente al componente rojo del color:

0000 0000 0000 0000 1111 1111 0100 0101 & 
0000 0000 0000 0000 0000 0000 1111 1111
------------------------------------------------
0000 0000 0000 0000 0000 0000 0100 0101

La variable red contiene el valor 0000 0000 0000 0000 0000 0000 0100 0101 que en hexadecimal equivale a 0x45

Para obtener el componente Green lo haremos de forma similar a lo realizado para el componente red pero en este caso desplazando los bits de color 8 posiciones a la derecha:

int green = (color >>> 8) & 0xFF;

Como resultado de estas operaciones la variable green contiene el valor 0000 0000 0000 0000 0000 0000 0110 0101 que en hexadecimal equivale a 0x65

Para obtener el componente Blue no es necesario hacer desplazamiento de bits ya que el valor de este componente se encuentra en los dos bytes de la derecha. Tan solo necesitaremos realizar la operación & 0xFF para poner todos los bits a cero excepto en los dos últimos bytes.

int blue = color & 0xFF;

Como resultado de esta operación la variable blue contiene el valor 0000 0000 0000 0000 0000 0000 1000 0101 que en hexadecimal equivale a 0x85

Como resumen podemos decir que los operadores a nivel de bits o operadores bitwise en Java permiten trabajar con los datos desde una perspectiva más cercana a su representación interna, actuando directamente sobre los bits que forman los valores enteros. Aunque su uso no es habitual en programas básicos, comprender cómo funcionan resulta clave para entender mejor cómo Java gestiona la información en memoria y para poder interpretar código más técnico. Estos operadores cobran especial sentido en situaciones como el manejo de opciones, el tratamiento de colores, la lectura de datos binarios o la programación de bajo nivel, aportando una base sólida para avanzar hacia conceptos más complejos del lenguaje.

Si en una expresión aparecen varios operadores bitwise, el orden de precedencia es el siguiente, ordenado de mayor precedencia a menor precedencia:

1. Operador ~ (NOT a nivel de bits o operador complemento a 1)
2. Operadores de desplazamiento << >> >>>
3. Operador & (AND)
4. Operador ^ (XOR)
5. Operador | (OR)

A la hora de escribir y evaluar expresiones que contienen operadores bitwise, debemos tener en cuenta que:

• Los operadores bitwise en Java tienen menor precedencia que los operadores aritméticos.
• Los operadores bitwise en Java tienen mayor precedencia que los operadores lógicos && y ||.
• Todos se evalúan de izquierda a derecha, excepto el operador ~

Los operadores bitwise en Java son operadores que trabajan directamente con los bits que componen los valores enteros. Permiten realizar operaciones bit a bit sobre la representación binaria de los datos.

Java dispone de los siguientes operadores bitwise: Operadores bitwise lógicos & (AND), | (OR), ^ (XOR), ~ (NOT) y operadores bitwise de desplazamiento << (desplazamiento a la izquierda), >> (desplazamiento a la derecha con signo) y >>> (desplazamiento a la derecha sin signo).

Se suelen utilizar para programación de bajo nivel, optimización de memoria, programación de sistemas, motores gráficos, drivers, compresión de datos, criptografía, etc.

No son habituales en programación básica, pero son muy importantes en programación avanzada, sistemas, gráficos, redes, programación de sistemas, etc.

Los operadores lógicos ( && || ! ) trabajan con operandos de tipo boolean, mientras que los operadores bitwise ( & | ^ ~ ) trabajan con operandos de tipo entero actuando sobre los bits de los operandos.

El operador >>> permite desplazar bits a la derecha sin conservar el signo, rellenando con ceros por la izquierda. Es útil cuando se tratan los números como datos binarios puros y no como valores con signo.

El operador ~ también llamado operador NOT a nivel de bits o operador complemento a 1, invierte todos los bits de un número entero convirtiendo los 0 en 1 y los 1 en 0. Se utiliza principalmente en operaciones de bajo nivel y máscaras de bits.

Los operadores bitwise solo se pueden utilizar con datos de tipo entero: byte, short, int, long y char. No pueden utilizarse con datos de tipo float o double.

Sí, suelen considerarse operadores de bajo nivel porque trabajan directamente sobre la representación binaria de los datos y están más próximos al funcionamiento interno del sistema.

Sí, no tanto por su uso inmediato, sino para comprender mejor cómo se almacenan y manipulan los datos en memoria y para poder interpretar en el futuro código más técnico.

Sí, los operadores de desplazamiento <<, >> y >>> forman parte de los operadores bitwise, ya que trabajan con bits desplazándolos dentro de un número entero.

Algunos errores frecuentes son confundir operadores lógicos && || con los operadores bitwise & |, no tener en cuenta el signo de los números a la hora de manipular sus bits o usar >> en lugar de >>> cuando se trabaja con datos binarios puros.