What does >> do in Java?

Question

Okay, I tried looking up what >>, or shift means, but it\'s way over my head as this site explains it: http://www.janeg.ca/scjp/oper/shift.html

Wh

Answer 1

>> the SHIFT RIGHT operator

Example:

class X
      { 
       public static void main(String args[])
       {
         System.out.println("20>>2 = "+20>>2);
       }
      }        

Output : 20>>2 = 5

Explanation:

Binary value of 20 is: 00000000000000000000000000010100

shift all bits 2 positions to right 00000000000000000000000000000101

It will give 5 ( 1*2^2 + 0*2^1 + 1*2^0 )

Answer 2

I once wrote an JApplet (bitorgel) and put it on my web page, where one can play around with bit operators. You can try it live, or download the source. AFAIK they work the same in C, C++ and Java - probably in C# too.

Answer 3

Computers are binary devices. Because of this, numbers are represented by a sequence of 1s and 0s.

Bitshifting is simply moving those sequences of 1s and 0s left or right.

So all the >> operator does is shift the bits towards the right one bit.

Consider the number 101:

// Assuming signed 8-bit integers
01100101 // How 101 is represented in binary
00110010 // After right shifting one bit, this represents 50

The least significant bit in this case was truncated. Obviously the devil's in the details, but that's all there is really to it.

The << operator does the opposite operation:

// Assuming signed 8-bit integers
01100101 // How 101 is represented in binary
11001010 // After left shifting one bit, this represents -54

// Assuming unsigned 8-bit integers
01100101 // How 101 is represented in binary
11001010 // After left shifting one bit, this represents 202

In this case, the most significant bit was truncated since I used only 8-bits. If the number had more bits, however:

// Assuming signed 16-bit integers
00000000 01100101 // How 101 is represented in binary
00000000 11001010 // After left shifting one bit, this represents 202
00000001 10010100 // After left shifting one bit again, this represents 404

So you may get different numbers depending on how many bits and the data types associated with those bits you're dealing with.

Addendum: If you're wondering how binary works, think about how the decimal number system works. Consider the number 5287. It can be written like this:

5287

But you can also write it out like this:

5287 = (5 * 1000) + (2 * 100) + (8 * 10) + (7 * 1)

Which you can then write out like this:

5287 = (5 * 10^3) + (2 * 10^2) + (8 * 10^1) + (7 * 10^0)

The above equation explains why the decimal number system is sometimes called the base-10 system. The decimal number system employs the use of 10 digits (0-9). Notice how the exponents correspond to digit position.

The binary number system, or the base-2 system, is the exact same thing but with the number two as the base of the exponents, and employing only two digits: 0 and 1.

5287 = 00010100 10100111 (base 2)
     = (0 * 2^15) + (0 * 2^14) + (0 * 2^13) + (1 * 2^12)
     + (0 * 2^11) + (1 * 2^10) + (0 * 2^9)  + (0 * 2^8)
     + (1 * 2^7)  + (0 * 2^6)  + (1 * 2^5)  + (0 * 2^4)
     + (0 * 2^3)  + (1 * 2^2)  + (1 * 2^1)  + (1 * 2^0)

Answer 4

Can I assume the kid I'm talking to knows a bit about binary? :)

All numbers can be represented in some kind of binary, like so:

   Base 10 : Base 2
   1 : 0001
   2 : 0010
   3 : 0011
   4 : 0100
   5 : 0101
   6 : 0110
   7 : 0111
   8 : 1000

... and so on.

The shift operators basically move all of the bits (1s or 0s) across one position. So, for example: 000111 >> 1

shifts all the bits in 000111 right by one number to produce this:

000011

000111 << 1

shifts all those bits left by one, to produce this:

001110

If you shift by more than one, then it just moves the bits further.

Now, depending on what language you're using and the kind of numbers you're working with, it can be a little bit more complicated than that. For example, if you are working in a language where the "most significant bit" (the one furthest to the left in a number) represents whether the number is signed or not, then the language will have to take that into account.

Mathematically speaking, if you take an integer (and ignore the risk of overflows, which are caused by the computer running out of space to store bits,) shift left by 1 (<< 1) is the equivalent of multiplying by 2, and shift right by 1 is the equivalent of dividing by 2. (Think a bit about what a "place value" in binary maths is worth, and that'll make sense)