public class DesplazamientoBitsJava {
	public static void main(String[] args) {
		System.out.println("CONTENIDO DE: WWW.JAVADESDE0.COM");
		System.out.println("El tamaño de un tipo de dato int guarda en memoria: " + Integer.BYTES + " bytes" + " o " + Integer.SIZE + " Bits.");
		System.out.println("Un byte equivale a 8 bits. Por tanto, si tenemos " + Integer.BYTES + " * 8 = " + (Integer.BYTES*8) + " Bits.");
		//OTRA MANERA DE SACAR EL TOTAL DE BITS POR PANTALLAS ES MULTIPLICAR EL TOTAL DE BYTES DE UN TIPO DE DATO POR 8 (EL NÚMERO DE BITS) O BIEN UTILIZAR Integer.SIZE
			System.out.println("\tSi transformamos el valor máximo a binario:  " + Integer.MAX_VALUE + " En binario:  " + Integer.toString(Integer.MAX_VALUE, 2));
			/*PARA REALIZAR LA CONVERSION DE INTEGER A BINARIO TENEMOS DOS OPCIONES:
			 * 1.  Integer.toString(A, B) --> A ES EL NÚMERO A CONVERTIR Y B LA BASE
			 * 	EN ESTE CASO, A ES EL VALOR MÁXIMO DE UN INTEGER (Integer.MAX_VALUE) Y B LA BASE, BINARIO ES BASE 2
			 * 2.Integer.toBinaryString(A) --> ESTA UNICAMENTE SE UNA PARA BINARIOS EN DIFERENCIA CON LA ANTERIOR, Y A ES EL NÚMERO A CONVERTIR.
			 */
			System.out.println("\tSi transformamos el valor mínimo a binario: " + Integer.MIN_VALUE + " En binario: " + Integer.toString(Integer.MIN_VALUE, 2));
		System.out.println("Si nos fijamos, el este caso en particular, el negativo tiene un número más que el positivo. ¿Sabéis el porque?");
		System.out.println("Un numero ya sea positivo, o negativo tiene: 31 bits y el 32 bits (es el del símbolo). " );
		System.out.println("Una manera de que podamos ver que esto es cierto es: ");
			System.out.println("\tSi al valor máximo de un integer le añadimos 1:  " + (Integer.toBinaryString(Integer.MAX_VALUE + 1)));
			System.out.println("\tPodemos ver que el 1 está acomapañado por 31 bits a 0, ese es el bit encargado de mostrar si un número es positivo + (valor 0) o negativo - (valor 1)");
			//AÑADIENDOSELO SIEMPRE A UN BINARIO SI HACEMOS INTEGER.MAXVALUE + 1, NOS DEVOLVERÁ EL VALOR MÍNIMO POR EL CONCEPTO QUE DE RANGOS CIRCULARES VISTO EN CLASES ANTERIORES.
		System.out.println("Esto es debido a que el último bit el 32 empezando de derecha a izquierda es el que nos indica si un número es + o negativo." );
		System.out.println("En caso de ser positivo, el número ocupa 31 bits y el bit 32 es un 0 al ser un 0 a la izquierda, este se omite, es como tener un tío en Grana (Granada)." );
		System.out.println("En caso de ser negativo, el número ocupa 32 bits, 31 del número y 1 del bit 32 (ya que un cero a la izquierda, es como tener un tío en graná (Granada)." );
		System.out.println("\tPor lo tanto, em el valor máximo contamos los 1: " + Integer.numberOfLeadingZeros(1));
		System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------");
		System.out.println("Bien, una vez entendemos todo esto, vamos a explicar el desplazamiento de bits sobre un INT: ");
		        int numeroA = 1008;
		        System.out.println("Número original en decimal A:\t" + numeroA + " IMPORTANTE MATIZAR QUE LA AUSENCIA DE SIGNO (+ O -) SE INTERPRETA COMO POSITIVO +");
		        System.out.println("A en binario:  \t\t\t" + Integer.toBinaryString(numeroA));
		        int numeroRotadoDerechaA = numeroA >> 2; //Desplaza numeroA 2 posiciones a la derecha
		        System.out.println("A desplazado 2 a la derecha:  \t" + Integer.toBinaryString(numeroRotadoDerechaA) +" Cuando se desplazan bits, si el número es positivo, son reemplazados por 0, ya que el signo del número es positivo.");
		        numeroRotadoDerechaA = numeroA >> 5; //Desplaza numeroA 5 posiciones a la derecha
		        System.out.println("A desplazado 5 a la derecha:  \t" + Integer.toBinaryString(numeroRotadoDerechaA) +" Cuando se desplazan bits, si el número es positivo, son reemplazados por 0, ya que el signo del número es positivo.");
		        System.out.println("-----------------------------------------------------------------");
		        int numeroB = 1;
		        int numeroRotadoDerechaB = numeroB >> 1;
		        System.out.println("Número original en decimal B:\t" + numeroB);
		        System.out.println("B en binario:  \t\t\t" + Integer.toBinaryString(numeroB));
		        System.out.println("B desplazado 1 a la derecha:  \t" + Integer.toBinaryString(numeroRotadoDerechaB) + " Cuando se desplazan bits, si el número es positivo, son reemplazados por 0, ya que el signo del número es positivo.");
		        System.out.println("-----------------------------------------------------------------");
		        int numeroC = -1;
		        int numeroRotadoDerechaC = numeroC >> 2;
		        System.out.println("Número original en decimal C:\t" + numeroC);
		        System.out.println("C en binario:  \t\t\t" + Integer.toBinaryString(numeroC));
		        System.out.println("C desplazado 2 a la derecha:  \t" + Integer.toBinaryString(numeroRotadoDerechaC) + " Cuando se desplazan bits, si el número es negativo, son reemplazados por 1, por lo tanto 31 bits de 1 + 1 bit en 1 del signo. En este caso, el resultado es el mismo.");
		        System.out.println("-----------------------------------------------------------------");
		        int numeroD = -4032;
		        int numeroRotadoDerechaD = numeroD >>> 10;
		        System.out.println("Si utilizamos >>> el triple, dicho operador, no tiene en cuenta el signo. Por lo tanto, trabajamos con 31 bits");
		        System.out.println("Número original en decimal A:\t" + numeroD);
		        System.out.println("D en binario:  \t\t\t" + Integer.toBinaryString(numeroD));
		        System.out.println("D desplazado 10 a la derecha:\t" + Integer.toBinaryString(numeroRotadoDerechaD));
		        System.out.println("-----------------------------------------------------------------");
		        int numeroE = 11;
		        int numeroRotadoDerechaE = numeroE >>> 1;
		        System.out.println("Si utilizamos >>> el triple, dicho operador, no tiene en cuenta el signo. Por lo tanto, trabajamos con 31 bits");
		        System.out.println("Número original en decimal E:\t" + numeroE);
		        System.out.println("E en binario:  \t\t\t" + Integer.toBinaryString(numeroE));
		        System.out.println("E desplazado 1 a la derecha:  \t\t" + Integer.toBinaryString(numeroRotadoDerechaE));
		        System.out.println("-----------------------------------------------------------------");
		        System.out.println("Desplazamiento de bits a la izquierda: ");
		        System.out.println("El desplazamiento a la izquierda únicamente se diferencia con el de la derecha en 2 matizes: ");
		        System.out.println("\t1. Utilizamos <<.");
		        System.out.println("\t2. Siempre sea + o - rellenará a 0.");
		        System.out.println("-----------------------------------------------------------------");
		        int numeroF = 255;
		        int numeroRotadoIzquierdaF = numeroF << 1;
		        System.out.println("Número original en decimal F:\t" + numeroF);
		        System.out.println("A en binario:  \t\t\t" + Integer.toBinaryString(numeroF));
		        System.out.println("A desplazado 1 a la izquierda:  \t" + Integer.toBinaryString(numeroRotadoIzquierdaF));
		        System.out.println("-----------------------------------------------------------------");
		        int numeroG = -524287;
		        int numeroRotadoIzquierdaG = numeroG << 15;
		        System.out.println("Número original en decimal F:\t" + numeroG);
		        System.out.println("A en binario:  \t\t\t" + Integer.toBinaryString(numeroG));
		        System.out.println("A desplazado izquierda:  \t" + Integer.toBinaryString(numeroRotadoIzquierdaG));
	}
}