¿Cómo funciona el cambio de bits en Java?

Tengo esta statement:

Suponga que el valor de bit de byte x es 00101011. ¿Cuál es el resultado de x>>2 ?

¿Cómo puedo progtwigrlo y alguien puede explicarme qué está haciendo?

En primer lugar, no puede cambiar un byte en java, solo puede cambiar un int o un long . Por lo tanto, el byte se someterá primero a promoción, por ejemplo

00101011 -> 00000000000000000000000000101011

o

11010100 -> 11111111111111111111111111010100

Ahora, x >> N significa (si lo ves como una cadena de dígitos binarios):

  • Los N bits más a la derecha se descartan
  • El bit más a la izquierda se replica tantas veces como sea necesario para rellenar el resultado con el tamaño original (32 o 64 bits), por ejemplo

00000000000000000000000000101011 >> 2 -> 00000000000000000000000000001010

11111111111111111111111111010100 >> 2 -> 11111111111111111111111111110101

Operadores de cambio

El binario de 32 bits para 00101011 es

00000000 00000000 00000000 00101011 , y el resultado es:

  00000000 00000000 00000000 00101011 >> 2(times) \\ \\ 00000000 00000000 00000000 00001010 

Cambia los bits de 43 a la izquierda por la distancia 2; se llena con el bit más alto (signo) en el lado izquierdo.

El resultado es 00001010 con un valor decimal de 10.

 00001010 8+2 = 10 

Cuando desplazas 2 bits a la derecha, sueltas los 2 bits menos significativos. Asi que:

 x = 00101011 x >> 2 // now (notice the 2 new 0's on the left of the byte) x = 00001010 

Esto es esencialmente lo mismo que dividir un int por 2, 2 veces.

En Java

 byte b = (byte) 16; b = b >> 2; // prints 4 System.out.println(b); 

Estos ejemplos cubren los tres tipos de cambios aplicados tanto a un número positivo como a un número negativo:

 // Signed left shift on 626348975 00100101010101010101001110101111 is 626348975 01001010101010101010011101011110 is 1252697950 after << 1 10010101010101010100111010111100 is -1789571396 after << 2 00101010101010101001110101111000 is 715824504 after << 3 // Signed left shift on -552270512 11011111000101010000010101010000 is -552270512 10111110001010100000101010100000 is -1104541024 after << 1 01111100010101000001010101000000 is 2085885248 after << 2 11111000101010000010101010000000 is -123196800 after << 3 // Signed right shift on 626348975 00100101010101010101001110101111 is 626348975 00010010101010101010100111010111 is 313174487 after >> 1 00001001010101010101010011101011 is 156587243 after >> 2 00000100101010101010101001110101 is 78293621 after >> 3 // Signed right shift on -552270512 11011111000101010000010101010000 is -552270512 11101111100010101000001010101000 is -276135256 after >> 1 11110111110001010100000101010100 is -138067628 after >> 2 11111011111000101010000010101010 is -69033814 after >> 3 // Unsigned right shift on 626348975 00100101010101010101001110101111 is 626348975 00010010101010101010100111010111 is 313174487 after >>> 1 00001001010101010101010011101011 is 156587243 after >>> 2 00000100101010101010101001110101 is 78293621 after >>> 3 // Unsigned right shift on -552270512 11011111000101010000010101010000 is -552270512 01101111100010101000001010101000 is 1871348392 after >>> 1 00110111110001010100000101010100 is 935674196 after >>> 2 00011011111000101010000010101010 is 467837098 after >>> 3 

>> es el operador aritmético de desplazamiento a la derecha. Todos los bits en el primer operando se desplazan el número de lugares indicados por el segundo operando. Los bits situados más a la izquierda en el resultado se establecen en el mismo valor que el bit situado más a la izquierda en el número original. (Esto es para que los números negativos sigan siendo negativos).

Aquí está su caso específico:

 00101011 001010 <-- Shifted twice to the right (rightmost bits dropped) 00001010 <-- Leftmost bits filled with 0s (to match leftmost bit in original number) 
 public class Shift { public static void main(String[] args) { Byte b = Byte.parseByte("00101011",2); System.out.println(b); byte val = b.byteValue(); Byte shifted = new Byte((byte) (val >> 2)); System.out.println(shifted); // often overloked are the methods of Integer int i = Integer.parseInt("00101011",2); System.out.println( Integer.toBinaryString(i)); i >>= 2; System.out.println( Integer.toBinaryString(i)); } } 

Salida:

 43 10 101011 1010 
 byte x = 51; //00101011 byte y = (byte) (x >> 2); //00001010 aka Base(10) 10 

No puede escribir literales binarios como 00101011 en Java para que pueda escribirlo en hexadecimal en su lugar:

 byte x = 0x2b; 

Para calcular el resultado de x >> 2 , puede escribir exactamente eso e imprimir el resultado.

 System.out.println(x >> 2); 

Puede usar, por ejemplo, esta API si desea ver la presentación de sus números en bitString. Uncommons Math

Ejemplo (en jruby)

 bitString = org.uncommons.maths.binary.BitString.new(java.math.BigInteger.new("12").toString(2)) bitString.setBit(1, true) bitString.toNumber => 14 

editar : Cambió el enlace de la API y agrega un pequeño ejemplo

00101011 = 43 en decimal

 class test { public static void main(String[] args){ int a= 43; String b= Integer.toBinaryString(a >> 2); System.out.println(b); } } 

Salida:

101011 pasa a ser 1010