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

Question

tengo esta declaración:

asumir el valor del bit del byte x es 00101011. lo que es el resultado de x>>2?

¿Cómo puedo programarlo y alguien me puede explicar qué está haciendo?

Answer 1

En primer lugar, puede no cambio de un byte en Java, sólo se puede cambiar una int o una long. Por lo tanto, el byte se someterá primero a promoción, p.

00101011 ->00000000000000000000000000101011

o

11010100 ->11111111111111111111111111010100

Ahora, x >> N medios (si se visualiza como una cadena de dígitos binarios):

• El más a la derecha N bits se descartan
• El bit situado 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), p.

00000000000000000000000000101011 >> 2 ->00000000000000000000000000001010

11111111111111111111111111010100 >> 2 ->11111111111111111111111111110101

Answer 2

Al desplazar 2 bits a la derecha, suelta los 2 bits menos significativos. Entonces:

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); 

Answer 3

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

byte x = 0x2b; 

Para calcular el resultado de x >> 2 que pueda entonces simplemente escriba exactamente eso e imprima el resultado.

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

Answer 4

>> es el operador de desplazamiento aritmético 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 siguen siendo negativas.)

Aquí es 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) 

Answer 5

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

Answer 6

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 

Answer 7

Se puede utilizar, 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: Cambiado enlace api y añadir un poco ejemplo

Answer 8

Los 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.

resultado es 00001010 con valor decimal 10.

00001010 
    8+2 = 10 

Answer 9

Estos ejemplos cubren los tres tipos de cambios aplicados a la vez un positivo y 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 

Answer 10

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 se convierte en 1010