對上面那段話的理解是：移位操作符操作的運算物件是二進位制的“位”，int型別是32位也就是2的5次冪 ！如果移32位以上，那麼原來的數的資訊會全部丟失，這樣也就沒有什麼意義了！所以上面的“只有右側的5個低位才會有用”說的是：移位操作符右端的那個數（化成二進位制）的低5位才有用，即 

因此，如果對一個int 型，進行移位，X < <y; 當y小於32時，移位後的結果一般都在我們的預料當中；而如果y大於32時，由於移位超出了int所能表示的範圍，這時就先把y化成二進位制數，然後取該二進位制數右端的低5位，再把這5位化成十進位制，此時的這個十進位制就是要對X移動的位數。

例如：         int int a=140;   
                     a << 34

                   System.out.println(Integer.toBinaryString(a << b));

上面那兩個語句的執行過程是：先把a化成二進位制數：10001100

執行語句 a << 34   對a左移32位時，先把 34化成二進位制：100010，對該二進位制數取右邊5位，即00010，化成十進位制數為2，所以實際上是對a左移兩位。現在，地球人都會知道上面程式的輸出結果是：1000110000

//////////////////////////////////////////////////

移位運算子和按位運算子一樣，同屬於位運算子，因此移位運算子的位指的也是二進位制位。它包括以下幾種：

1. 左移位（<<）：將操作符左側的運算元向左移動操作符右側指定的位數。移動的規則是在二進位制的低位補0。
2. 有符號右移位（>>）：將操作符左側的運算元向右移動操作符右側指定的位數。移動的規則是，如果被運算元的符號為正，則在二進位制的高位補0；如果被運算元的符號為負，則在二進位制的高位補1。
3. 無符號右移位（>>>）：將操作符左側的運算元向右移動操作符右側指定的位數。移動的規則是，無論被運算元的符號是正是負，都在二進位制位的高位補0。

注意，移位運算子不存在“無符號左移位（<<<）”一說。與按位運算子一樣，移位運算子可以用於byte、short、int、long等整數型別，和字串型別char，但是不能用於浮點數型別float、double；當然，在Java5.0及以上版本中，移位運算子還可用於byte、short、int、long、char對應的包裝器類。我們可以參照按位運算子的示例寫一個測試程式來驗證，這裡就不再舉例了。

與按位運算子不同的是，移位運算子不存在短路不短路的問題。

寫到這裡就不得不提及一個在面試題中經常被考到的題目：

這裡所謂的最有效率，實際上就是通過最少、最簡單的運算得出想要的結果，而移位是計算機中相當基礎的運算了，用它來實現準沒錯了。左移位“<<”把被運算元每向左移動一位，效果等同於將被運算元乘以2，而2*8=（2*2*2*2），就是把2向左移位3次。因此最有效率的計算2乘以8的方法就是“2<<3”。

最後，我們再來考慮一種情況，當要移位的位數大於被運算元對應資料型別所能表示的最大位數時，結果會是怎樣呢？比如，1<<35=?呢？

這裡就涉及到移位運算的另外一些規則：

1. byte、short、char在做移位運算之前，會被自動轉換為int型別，然後再進行運算。
2. byte、short、int、char型別的資料經過移位運算後結果都為int型。
3. long經過移位運算後結果為long型。
4. 在左移位（<<）運算時，如果要移位的位數大於被運算元對應資料型別所能表示的最大位數，那麼先將要求移位數對該型別所能表示的最大位數求餘後，再將被運算元移位所得餘數對應的數值，效果不變。比如1<<35=1<<(35%32)=1<<3=8。
5. 對於有符號右移位（>>）運算和無符號右移位（>>>）運算，當要移位的位數大於被運算元對應資料型別所能表示的最大位數時，那麼先將要求移位數對該型別所能表示的最大位數求餘後，再將被運算元移位所得餘數對應的數值，效果不變。。比如100>>35=100>>(35%32)=100>>3=12。

下面的測試程式碼驗證了以上的規律：

1. publicabstractclass Test {   
2. publicstaticvoid main(String[] args) {   
3.         System.out.println("1 << 3 = " + (1 << 3));   
4.         System.out.println("(byte) 1 << 35 = " + ((byte) 1 << (32 + 3)));   
5.         System.out.println("(short) 1 << 35 = " + ((short) 1 << (32 + 3)));   
6.         System.out.println("(char) 1 << 35 = " + ((char) 1 << (32 + 3)));   
7.         System.out.println("1 << 35 = " + (1 << (32 + 3)));   
8.         System.out.println("1L << 67 = " + (1L << (64 + 3)));   
9. // 此處需要Java5.0及以上版本支援 
10.         System.out.println("new Integer(1) << 3 = " + (new Integer(1) << 3));   
11.         System.out.println("10000 >> 3 = " + (10000 >> 3));   
12.         System.out.println("10000 >> 35 = " + (10000 >> (32 + 3)));   
13.         System.out.println("10000L >>> 67 = " + (10000L >>> (64 + 3)));   
14.     }   
15. }  

1. publicabstractclass Test { publicstaticvoid main(String[] args) { System.out.println("1 << 3 = " + (1 << 3)); System.out.println("(byte) 1 << 35 = " + ((byte) 1 << (32 + 3))); System.out.println("(short) 1 << 35 = " + ((short) 1 << (32 + 3))); System.out.println("(char) 1 << 35 = " + ((char) 1 << (32 + 3))); System.out.println("1 << 35 = " + (1 << (32 + 3))); System.out.println("1L << 67 = " + (1L << (64 + 3))); // 此處需要Java5.0及以上版本支援 System.out.println("new Integer(1) << 3 = " + (new Integer(1) << 3)); System.out.println("10000 >> 3 = " + (10000 >> 3)); System.out.println("10000 >> 35 = " + (10000 >> (32 + 3))); System.out.println("10000L >>> 67 = " + (10000L >>> (64 + 3))); } }

執行結果：

1. 1 << 3 = 8
2. (byte) 1 << 35 = 8
3. (short) 1 << 35 = 8
4. (char) 1 << 35 = 8
5. 1 << 35 = 8
6. 1L << 67 = 8
7. new Integer(1) << 3 = 8
8. 10000 >> 3 = 1250
9. 10000 >> 35 = 1250
10. 10000L >>> 67 = 1250