Curso de Java. Operadores a nivel de Bits.
Los Operadores a nivel de bits de uso común en java son los siguientes:
| Operador. | Uso. |
|---|---|
| & | AND a nivel de bit. |
| | | OR a nivel de bit. |
| ^ | XOR a nivel de bit. |
| ~ | Complemento unitario. |
| << | Desplaza a la Izquierda. |
| >> | Desplaza a la Derecha. |
| >>> | Desplaza a la Izquierda sin signo. |
Estos operadores hacen las operaciones convirtiendo los valores u operandos expresados normalmente en base decimal de una operación a binario y después realizar dicha operación.
Como no es muy fácil de entender como actuan este tipo de operadores, sobre todo para el visitante que nunca ha trabajado con conversiones de números, vamos a ver una breve explicación de las equivalencias entre números decimales y binarios.
Para convertir un número decimal en binario hay que dividir el número decimal entre 2 de manera sucesiva, e ir apuntando el último cociente que nos resulte y los restos que nos vayan saliendo. Veamos un ejemplo:
Tenemos el numero decimal 20 y lo queremos convertir a binario. Veamos el proceso.
1 2 3 4 5 | 20 |_2_ 0 10 |_2_ 0 5 |_2_ 1 2 |_2_ 0 1 // Ultimo cociente. |
Tal como hemos dicho antes cojemos el último cociente en este caso es 1 y los restos que nos han ido saliendo en orden inverso al orden de aparición, es decir cojemos el último resto, después el penúltimo, hasta llegar al primero. Al final el numéro binario seria este:
10100
Como dijimos en la página de introducción del curso los bits se agrupan en Bytes y 1Byte equivale a 8bits. El número que nos ha salido tiene 5 bits, por tanto nos faltarian 3 bits más, para formar un byte, entonces rellenaremos con ceros a la izquierda del número anterior, para tener un Byte completo. De esta forma el número binario final que nos quedaría sería este:
20 (en decimal) = 00010100 (En binario).
A continuación expongo una tabla con algunas equivalencias entre números decimales a binarios:
| DECIMAL. | BINARIO. |
|---|---|
| 1 | 00000001 |
| 2 | 00000010 |
| 3 | 00000011 |
| 4 | 00000100 |
| 5 | 00000101 |
| 6 | 00000110 |
| 7 | 00000111 |
| 8 | 00001000 |
| 9 | 00001001 |
| 10 | 00001010 |
He señalado en color rojo la conversión del número 8 para que veais una manera rápida de sacar un número binario de un decimal dado. Si os fijais el número 10 ( 00001010 ), está compuesto de unnúmero 8 ( 00001000 ) + un número 2 ( 00000010 ). De acuerdo a esto, podemos sacar rápidamente el número 15 por ejemplo que sería equivalente al número 8 ( 00001000 ) en binario + el número 7 (00000111) en binario, resultando finalmente ( 00001111 ). Para el número 16 se añadiría un 1 a la izquierda y se pondrían a 0 el resto, ( 00010000 ). Utilizando esta técnica nos evitamos el tener que andar haciendo divisiones.
Por otro lado tenemos que saber que 8 equivale a ( 00001000 ), 16 a (00010000 ), 32 a ( 00100000 )…y así sucesivamente, es decir los números que podemos utilizar como referencias para calcular otros números, van en orden ( x2 ).
El mayor número decimal que podemos expresar con 1 Byte es es número: 255 que al descomponerlo vemos que esta compuesto así:
1 2 3 4 5 6 7 8 9 10 | 10000000 - 128 en decimal. 01000000 - 64 en decimal. 00100000 - 32 en decimal. 00010000 - 16 en decimal. 00001000 - 8 en decimal. 00000100 - 4 en decimal. 00000010 - 2 en decimal. 00000001 - 1 en decimal. ------------- 11111111 |
Una vez aclarado la conversión de Decimal a binario, vamos a realizar unos cuantos ejemplos de uso de los operadores a nivel de bits:
Ejemplo de uso del Operador & (AND a nivel de bit).
Vamos a realizar algunos cálculos utilizando por ejemplo los números decimales o en base 10 «4» y «6» .
1 2 3 4 5 6 7 8 9 10 11 | 4 & 6 = 00000100 & 00000110 = 00000100 = 4 (Equivale a 4 en decimal) El operador & realiza la multiplicación lógica bit a bit. Dará como resultado 1 si ambos bits valen "1", en cualquier otro caso el resultado será "0". Con la siguiente forma de presentar la operación, quizás se vea más claro: 0 0 0 0 0 1 0 0 -- 4 0 0 0 0 0 1 1 0 -- 6 ------------------ 0 0 0 0 0 1 0 0 -- Resultado 4 Como veis se compara verticalmente cada bit de un número, con el bit correspondiente del otro número y solo dá como resultado "1" cuando ambos bits valen "1" . |
Ejemplo de uso del Operador | (OR a nivel de bit).
1 2 3 4 5 6 7 8 | 4 | 6 = 00000100 | 00000110 = 00000110 = 6 (Equivale a 6 en decimal) El operador | realiza la suma lógica bit a bit. Dará como resultado 1 si al menos uno de los dos bits vale "1", dará "0" cuando ambos valgan "0": 0 0 0 0 0 1 0 0 -- 4 0 0 0 0 0 1 1 0 -- 6 ------------------ 0 0 0 0 0 1 1 0 -- Resultado 6 |
Ejemplo de uso del Operador ^ (XOR a nivel de bit).
1 2 3 4 5 6 7 8 | 4 ^ 6 = 00000100 ^ 00000110 = 00000010 = 2 (Equivale a 2 en decimal) El operador ^ Dará como resultado 1 solamente cuando uno de los dos bits valga "1", dará "0" en cualquier otro caso: 0 0 0 0 0 1 0 0 -- 4 0 0 0 0 0 1 1 0 -- 6 ------------------ 0 0 0 0 0 0 1 0 -- Resultado 2 |
Ejemplo de uso de Complemento unitario ~.
int a = 3, b= 0;
b = ~ a;
b = El complemento unitario cambia los bits, es decir donde hay un «1» coloca un «0» y viceversa, antes de realizar la operación en este caso asignación y presenta el resultado con signo negativo.
Ejemplo de uso de Desplazamiento a la Izquierda. <<.
6 << 3 = 00000110
<< 000 = 00110000 = Resultado 48
Este operador desplaza tantos bits a la Izq, como indica el número escrito detrás de él. En este caso queremos desplazar «3 bits» hacia la izquierda del número «6» (00000110). Para ello eliminamos los 3 primeros bits 00000110 y añadimos al final tantos «0» como bits hayamos eliminado, 00110000, resultando el número decimal «48».
Ejemplo de uso de Desplazamiento a la Derecha. >>.
97 >> 2 = 01100001
>> 00 = 00011000 = Resultado 24
Este operador desplaza tantos bits a la Drch, como indica el número escrito detrás de él. En este caso queremos desplazar «2 bits» hacia la Drch. del número «97» (01100001). Para ello eliminamos los «2 últimos bits 01100001 y añadimos al principio tantos «0» como bits hayamos eliminado, 00011000, resultando el número decimal «24».