“>>”和“>>>” java

“>>”算术右移运算符, 表示带符号右移，它使用最高位填充移位后左侧的空位。右移的结果为：每移一位，第一个操作数被2除一次，移动的次数由第二个操作数确定。
按二进制形式把所有的数字向右移动对应巍峨位数，低位移出（舍弃），高位的空位补符号位，即正数补零，负数补

“>>>“无符号右移运算,逻辑右移, 表示无符号右移, 只对位进行操作，没有算术含义，它用0填充左侧的空位。
按二进制形式把所有的数字向右移动对应位数，低位移出（舍弃），高位的空位补零。对于正数来说和带符号右移相同，对于负数来说不同。
j>>>i 与 j/(int)(Math.pow(2,i))的结果相同，其中i和j是整形。

算术右移不改变原数的符号，而逻辑右移不能保证这点。
移位运算符约简其右侧的操作数，当左侧操作数是int类型时，右侧以32取模；当左侧是long类型时，右侧以64取模。

测试代码1：
    public class Test   
    {   
    public static void main(String[] args)   
    {   
    System.out.println("1、以下测试>:");   
    int a = 1, b = 2;   
    System.out.println(a > b);   
    System.out.println("\n2、以下测试>>:");   
    System.out.println("15 >> 2 = " + (15 >> 2));   
    System.out.println("\n3、以下测试>>>:");   
    for (int i = 0; i < 10; i++)   
    {   
    for (int j = 0; j < 500; j = j + 5)   
    {   
    System.out.println(j / (int) (Math.pow(2, i)));   
    System.out.println(j >>> i);   
    }   
    }   
    }  
    }

测试代码2：
    public class Test {  
        public Test(){  
            System.out.println("=============算术右移 >> ===========");  
            int i=0xC0000000;  
            System.out.println("移位前：i= "+i+" = "+Integer.toBinaryString(i)+"(B)");  
            i=i>>28;  
            System.out.println("移位后：i= "+i+" = "+Integer.toBinaryString(i)+"(B)");  
            System.out.println("---------------------------------");  
            int j=0x0C000000;  
            System.out.println("移位前：j= "+j+" = "+Integer.toBinaryString(j)+"(B)");  
            j=j>>24;  
            System.out.println("移位后：j= "+j+" = "+Integer.toBinaryString(j)+"(B)");  
            System.out.println("\n");  
            System.out.println("==============逻辑右移 >>> =============");  
            int m=0xC0000000;  
            System.out.println("移位前：m= "+m+" = "+Integer.toBinaryString(m)+"(B)");  
            m=m >>> 28;  
            System.out.println("移位后：m= "+m+" = "+Integer.toBinaryString(m)+"(B)");  
            System.out.println("---------------------------------");  
            int n=0x0C000000;  
            System.out.println("移位前：n= "+n+" = "+Integer.toBinaryString(n)+"(B)");  
            n=n>>24;  
            System.out.println("移位后：n= "+n+" = "+Integer.toBinaryString(n)+"(B)");  
            System.out.println("\n");  
            System.out.println("==============移位符号的取模===============");  
            int a=0xCC000000;  
            System.out.println("移位前：a= "+a+" = "+Integer.toBinaryString(a)+"(B)");  
            System.out.println("算术右移32：a="+(a>>32)+" = "+Integer.toBinaryString(a>>32)+"(B)");  
            System.out.println("逻辑右移32：a="+(a>>>32)+" = "+Integer.toBinaryString(a>>>32)+"(B)");  
        }  
        public static void main(String[] args){  
            new Test();  
        }  
    }  

运行结果：
=============算术右移 >> ===========
移位前：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)