Convertir un carácter a su representación binaria

En base a un software que estoy desarrollando y de un par de preguntas que me han hecho algunos lectores del blog, he preparado este sencillo ejemplo en el que convertimos una variable char a su representación binaria. Y de paso mostrar un breve ejemplo de cómo recibir argumentos desde la ejecución del programa. Comienzo explicando lo más sencillo.

Paso de parámetros al ejecutar el programa

Al momento de ejecutar una aplicación de cualquier índole desde la consola, es posible añadir datos o flags que le indican al programa cómo debe actuar. Así por ejemplo para compilar un programa en C usando gcc hacemos algo como esto:

gcc -o archivo programa.c

En ese caso, estamos indicando a gcc que el archivo de resultante deberá llamarse “salida” y que el fichero a compilar se llama “programa.c”. En realidad (y lo que debemos tener en cuenta), los parámetros que le hemos pasado a gcc en la línea de comandos son 3 cadenas: “-o”, “archivo” y “programa.c”. gcc las procesa y realiza las tareas indicadas.

De igual forma funciona en Java, para lo cual podemos usar el arreglo de String llamado args, que declaramos en el método main de todos nuestros programas. Así, por ejemplo, si ejecutamos un programa en Java de la siguiente manera:

java MiPrograma arg1 param2 flag

El arreglo args contendrá 3 cadenas: “arg1″, “param2″ y “flag”, las cuales se pueden utilizar dentro del método main de manera normal, es decir, referenciándolas por su indice. Así, para este caso, args[0]="arg1", args[1]="param2" y args[2]="flag". Lo demás es utilizar normalmente dichas variables dentro del programa.

Convirtiendo un carácter en su representación binaria

Vamos con algo más difícil… primero es necesario tener claro el uso de algunos operadores binarios. Por lo general siempre trabajamos en un nivel superior más cómodo, es decir, utilizamos directamente tipos de datos primitivos (int, double, long) u objetos (String, Integer, Double), por lo que la mayoría de las veces no estamos familiarizados con la manipulación directa de bits. Veámos entonces una tabla en donde se muestran los operadores binarios en Java:

Para el caso que nos atañe vamos a utilizar el operador de desplazamiento a la izquierda (<<) y el operador AND (&). Y por tal motivo un pequeño ejemplo de los mismos tomados de Wiklibros:

Desplazamiento a la izquierda con signo (cíclico)
Deseamos correr el número 33 dos posiciones a la izquierda. Entonces realizamos :

int j = 33;
int k = j << 2;

Este es el resultado:

00000000000000000000000000100001 : j = 33
00000000000000000000000010000100 : k = 33 << 2 ; k = 132

Cada “hueco” que queda a la derecha tras correr este número se rellena con los dígitos que van saliendo por la izquierda (ceros en este caso). Si prestamos atención, observaremos que esta operación multiplicó a j por 2 tantas veces como posiciones se ha desplazado. En este caso se multiplicó por 4 ( 2 x 2 ). Como el signo del número puede cambiar tras la operación, se denomina desplazamiento con signo.

Operador AND de Bits
Si ambos bits comparados son 1, establece el resultado en 1. De lo contrario da como resultado 0.

int k = 132;   // k: 00000000000000000000000010000100
int l = 144;   // l: 00000000000000000000000010010000
int m = k & l; // m: 00000000000000000000000010000000

El resultado da 128

Conociendo esto, podemos ahora entender el funcionamiento del programa en cuestión:

public class CharAByte {
    public static void main(String args[]) {
    	char caracter;
    	if ( args.length == 0 )
    	{
    		System.out.println("Uso:\n\tjava CharAByte caracter\n\nEjemplo:\n\tjava CharAByte R");
    		System.exit (0);
    	}
    	caracter = args[ 0 ].charAt(0);
    	byte byteDeCaracter = (byte)caracter;
    	for( int i = 7; i>=0; i--)
    		System.out.print( ( ( ( byteDeCaracter &amp; ( 1<<i ) ) > 0 ) ? "1" : "0" ) );
    }
}

Una breve explicación:

• En la línea 4 verificamos si el usuario incluyó algún argumento mediante la línea de comandos. Para tal fin utilizamos args.length que devuelve la longitud del arreglo args, y en caso que sea equivalente a cero (0) se imprime un mensaje para enseñar al usuario el correcto uso del programa.
• En la línea 9 asígnamos a la variable caracter la letra que digitó el usuario.
• Luego viene lo divertido (línea 12). Tenemos un for que itera 8 veces (1 byte = 8 bits). Y dentro imprimimos un uno o un cero, dependiendo de si comparando con AND el carácter, contra cada uno de los valores binarios que se forman al hacer 1<<i (10000000, 01000000, 00100000, 00010000, etc.), se obtiene un valor distinto de cero.
  Nota: Es mucho más fácil de entender este proceso si conoces cómo funciona el sistema binario, y cómo se pasa de binario a decimal y viceversa.

Un ejemplo del programa funcionando:

$java CharAByte A
01000001
$java CharAByte M
01001101
$java CharAByte O
01001111
$java CharAByte R
01010010

¿Cómo podemos verificar que el resultado es correcto? Muy sencillo, por ejemplo para la ‘A’ el resultado fue 01000001, entonces conviertes ese valor a décimal y obtendrás 65, su equivalencia en ASCII. Podemos verificar que el programa funciona perfectamente mirando un famoso grafiti, en donde escribieron AMOR en binario:

Descargar código fuente

4 Comentarios | deja el tuyo