How does bitshifting work in Java?

The binary 32 bits for 00101011 is

00000000 00000000 00000000 00101011, and the result is:

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

Shifts the bits of 43 to right by distance 2; fills with highest(sign) bit on the left side.

Result is 00001010 with decimal value 10.

00001010 8+2 = 10 

When you shift right 2 bits you drop the 2 least significant bits. So:

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

This is essentially the same thing as dividing an int by 2, 2 times.

In Java

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

These examples cover the three types of shifts applied to both a positive and a negative number:

// 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 

>> is the Arithmetic Right Shift operator. All of the bits in the first operand are shifted the number of places indicated by the second operand. The leftmost bits in the result are set to the same value as the leftmost bit in the original number. (This is so that negative numbers remain negative.)

Here's your specific case:

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

Output:

43 10 101011 1010 

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

You can't write binary literals like 00101011 in Java so you can write it in hexadecimal instead:

byte x = 0x2b; 

To calculate the result of x >> 2 you can then just write exactly that and print the result.

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

You can use e.g. this API if you would like to see bitString presentation of your numbers. Uncommons Math

Example (in jruby)

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

edit: Changed api link and add a little example

00101011 = 43 in decimal

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

Output:

101011 becomes 1010