Come funziona il bithifting in Java?

Question

Ho questa dichiarazione:

Assumere il valore di bit del byte x è 00101011. qual è il risultato di x>>2?

Come posso programmarlo e qualcuno può spiegarmi cosa sta facendo?

Answer 1

In primo luogo, è possibile non spostamento di un byte in Java, si può solo spostare un int o un long. Quindi lo byte verrà sottoposto a promozione prima, ad es.

00101011 ->00000000000000000000000000101011

o

11010100 ->11111111111111111111111111010100

Ora, x >> N mezzo (se si visualizza come una stringa di cifre binarie):

• Il più a destra N bit scartati
• Il bit più a sinistra viene replicato tante volte quanto necessario per caricare il risultato nella dimensione originale (32 o 64 bit), ad es.

00000000000000000000000000101011 >> 2 ->00000000000000000000000000001010

11111111111111111111111111010100 >> 2 ->11111111111111111111111111110101

Answer 2

Quando si spostano a destra 2 bit si rilasciano i 2 bit meno significativi. Dunque:

x = 00101011 

x >> 2 

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

Questa è essenzialmente la stessa cosa della divisione di un int di 2, 2 volte.

In Java

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

Answer 3

Non è possibile scrivere letterali binari come 00101011 in Java in modo da poter scrivere in esadecimale invece:

byte x = 0x2b; 

Per calcolare il risultato di x >> 2 si può quindi scrivi esattamente questo e stampa il risultato.

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

Answer 4

>> è l'aritmetica a destra dell'operatore Shift. Tutti i bit del primo operando sono spostati del numero di posizioni indicato dal secondo operando. I bit più a sinistra nel risultato sono impostati sullo stesso valore del bit più a sinistra nel numero originale. (Questo è così che i numeri negativi rimangono negativi.)

Ecco il vostro caso specifico:

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

uscita:

43 
10 
101011 
1010 

Answer 7

È possibile utilizzare ad esempio questa API se desideri vedere la presentazione bitString dei tuoi numeri. Uncommons Math

Esempio (in jruby)

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

modifica: Modificato collegamento api e aggiungere un po esempio

Answer 8

I binari 32 bit per 00101011 è

00000000 00000000 00000000 00101011, e il risultato è:

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

Sposta i bit di 43 a sinistra in base alla distanza 2; riempie con il bit più alto (segno) sul lato sinistro.

risultato è 00001010 con valore decimale 10.

00001010 
    8+2 = 10 

Answer 9

Questi esempi coprono i tre tipi di turni applicati sia positivo e un numero 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 in decimale

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

Uscita:

101011 diventa 1010