java的算术右移（>>）与逻辑右移（>>>）

文章转载来源：http://blog.csdn.net/zgrjkflmkyc/article/details/12186139

运算符“>>”执行算术右移，它使用最高位填充移位后左侧的空位。右移的结果为：每移一位，第一个操作数被2除一次，移动的次数由第二个操作数确定。

逻辑右移或叫无符号右移运算符“>>>“只对位进行操作，没有算术含义，它用0填充左侧的空位。

算术右移不改变原数的符号，而逻辑右移不能保证这点。

移位运算符约简其右侧的操作数，当左侧操作数是int类型时，右侧以32取模；当左侧是long类型时，右侧以64取模。

测试代码如下：

[java] view plain copy

1. public class Test {  
2.   
3.     public Test(){  
4.         System.out.println("=============算术右移 >> ===========");  
5.         int i=0xC0000000;  
6.         System.out.println("移位前：i= "+i+" = "+Integer.toBinaryString(i)+"(B)");  
7.         i=i>>28;  
8.         System.out.println("移位后：i= "+i+" = "+Integer.toBinaryString(i)+"(B)");  
9.           
10.         System.out.println("---------------------------------");  
11.           
12.         int j=0x0C000000;  
13.         System.out.println("移位前：j= "+j+" = "+Integer.toBinaryString(j)+"(B)");  
14.         j=j>>24;  
15.         System.out.println("移位后：j= "+j+" = "+Integer.toBinaryString(j)+"(B)");  
16.   
17.         System.out.println("\n");  
18.         System.out.println("==============逻辑右移 >>> =============");  
19.         int m=0xC0000000;  
20.         System.out.println("移位前：m= "+m+" = "+Integer.toBinaryString(m)+"(B)");  
21.         m=m >>> 28;  
22.         System.out.println("移位后：m= "+m+" = "+Integer.toBinaryString(m)+"(B)");  
23.           
24.         System.out.println("---------------------------------");  
25.           
26.         int n=0x0C000000;  
27.         System.out.println("移位前：n= "+n+" = "+Integer.toBinaryString(n)+"(B)");  
28.         n=n>>24;  
29.         System.out.println("移位后：n= "+n+" = "+Integer.toBinaryString(n)+"(B)");  
30.           
31.         System.out.println("\n");  
32.         System.out.println("==============移位符号的取模===============");  
33.         int a=0xCC000000;  
34.         System.out.println("移位前：a= "+a+" = "+Integer.toBinaryString(a)+"(B)");  
35.         System.out.println("算术右移32：a="+(a>>32)+" = "+Integer.toBinaryString(a>>32)+"(B)");  
36.         System.out.println("逻辑右移32：a="+(a>>>32)+" = "+Integer.toBinaryString(a>>>32)+"(B)");  
37.     }  
38.       
39.     public static void main(String[] args){  
40.         new Test();  
41.     }  
42. }  

运行结果：=============算术右移 >> ===========
移位前：i= -1073741824 = 11000000000000000000000000000000(B)
移位后：i= -4 = 11111111111111111111111111111100(B)
---------------------------------
移位前：j= 201326592 = 1100000000000000000000000000(B)
移位后：j= 12 = 1100(B)


==============逻辑右移 >>> =============
移位前：m= -1073741824 = 11000000000000000000000000000000(B)
移位后：m= 12 = 1100(B)
---------------------------------
移位前：n= 201326592 = 1100000000000000000000000000(B)
移位后：n= 12 = 1100(B)


==============移位符号的取模===============
移位前：a= -872415232 = 11001100000000000000000000000000(B)
算术右移32：a=-872415232 = 11001100000000000000000000000000(B)
逻辑右移32：a=-872415232 = 11001100000000000000000000000000(B)