移位运算符

ㄣ负二代

移位运算符面向的运算对象也是二进制的“位”。可单独用它们处理整数类型（主类型的一种）。左移位运算符（<<）能将运算符左边的运算对象向左移动运算符右侧指定的位数（在低位补0）。“有符号”右移位运算符（>>）则将运算符左边的运算对象向右移动运算符右侧指定的位数。“有符号”右移位运算符使用了“符号扩展”：若值为正，则在高位插入0；若值为负，则在高位插入1。Java也添加了一种“无符号”右移位运算符（>>>），它使用了“零扩展”：无论正负，都在高位插入0。这一运算符是C或C++没有的。
若对char，byte或者short进行移位处理，那么在移位进行之前，它们会自动转换成一个int。只有右侧的5个低位才会用到。这样可防止我们在一个int数里移动不切实际的位数。若对一个long值进行处理，最后得到的结果也是long。此时只会用到右侧的6个低位，防止移动超过long值里现成的位数。但在进行“无符号”右移位时，也可能遇到一个问题。若对byte或short值进行右移位运算，得到的可能不是正确的结果（Java 1.0和Java 1.1特别突出）。它们会自动转换成int类型，并进行右移位。但“零扩展”不会发生，所以在那些情况下会得到-1的结果。可用下面这个例子检测自己的实现方案：

1. //: URShift.java
   
2. // Test of unsigned right shift
   
3. 
   
4. public class URShift {
   
5.   public static void main(String[] args) {
   
6.     int i = -1;
   
7.     i >>>= 10;
   
8.     System.out.println(i);
   
9.     long l = -1;
   
10.     l >>>= 10;
    
11.     System.out.println(l);
    
12.     short s = -1;
    
13.     s >>>= 10;
    
14.     System.out.println(s);
    
15.     byte b = -1;
    
16.     b >>>= 10;
    
17.     System.out.println(b);
    
18.   }
    
19. } ///:~

复制代码

移位可与等号（<<=或>>=或>>>=）组合使用。此时，运算符左边的值会移动由右边的值指定的位数，再将得到的结果赋回左边的值。
下面这个例子向大家阐示了如何应用涉及“按位”操作的所有运算符，以及它们的效果：

1. //: BitManipulation.java
   
2. // Using the bitwise operators
   
3. import java.util.*;
   
4. 
   
5. public class BitManipulation {
   
6.   public static void main(String[] args) {
   
7.     Random rand = new Random();
   
8.     int i = rand.nextInt();
   
9.     int j = rand.nextInt();
   
10.     pBinInt("-1", -1);
    
11.     pBinInt("+1", +1);
    
12.     int maxpos = 2147483647;
    
13.     pBinInt("maxpos", maxpos);
    
14.     int maxneg = -2147483648;
    
15.     pBinInt("maxneg", maxneg);
    
16.     pBinInt("i", i);
    
17.     pBinInt("~i", ~i);
    
18.     pBinInt("-i", -i);
    
19.     pBinInt("j", j);
    
20.     pBinInt("i & j", i & j);
    
21.     pBinInt("i | j", i | j);
    
22.     pBinInt("i ^ j", i ^ j);
    
23.     pBinInt("i << 5", i << 5);
    
24.     pBinInt("i >> 5", i >> 5);
    
25.     pBinInt("(~i) >> 5", (~i) >> 5);
    
26.     pBinInt("i >>> 5", i >>> 5);
    
27.     pBinInt("(~i) >>> 5", (~i) >>> 5);
    
28. 
    
29.     long l = rand.nextLong();
    
30.     long m = rand.nextLong();
    
31.     pBinLong("-1L", -1L);
    
32.     pBinLong("+1L", +1L);
    
33.     long ll = 9223372036854775807L;
    
34.     pBinLong("maxpos", ll);
    
35.     long lln = -9223372036854775808L;
    
36.     pBinLong("maxneg", lln);
    
37.     pBinLong("l", l);
    
38.     pBinLong("~l", ~l);
    
39.     pBinLong("-l", -l);
    
40.     pBinLong("m", m);
    
41.     pBinLong("l & m", l & m);
    
42.     pBinLong("l | m", l | m);
    
43.     pBinLong("l ^ m", l ^ m);
    
44.     pBinLong("l << 5", l << 5);
    
45.     pBinLong("l >> 5", l >> 5);
    
46.     pBinLong("(~l) >> 5", (~l) >> 5);
    
47.     pBinLong("l >>> 5", l >>> 5);
    
48.     pBinLong("(~l) >>> 5", (~l) >>> 5);
    
49.   }
    
50.   static void pBinInt(String s, int i) {
    
51.     System.out.println(
    
52.       s + ", int: " + i + ", binary: ");
    
53.     System.out.print("   ");
    
54.     for(int j = 31; j >=0; j--)
    
55.       if(((1 << j) &  i) != 0)
    
56.         System.out.print("1");
    
57.       else
    
58.         System.out.print("0");
    
59.     System.out.println();
    
60.   }
    
61.   static void pBinLong(String s, long l) {
    
62.     System.out.println(
    
63.       s + ", long: " + l + ", binary: ");
    
64.     System.out.print("   ");
    
65.     for(int i = 63; i >=0; i--)
    
66.       if(((1L << i) & l) != 0)
    
67.         System.out.print("1");
    
68.       else
    
69.         System.out.print("0");
    
70.     System.out.println();
    
71.   }
    
72. } ///:~

复制代码

程序末尾调用了两个方法：pBinInt()和pBinLong()。它们分别操作一个int和long值，并用一种二进制格式输出，同时附有简要的说明文字。目前，可暂时忽略它们具体的实现方案。
大家要注意的是System.out.print()的使用，而不是System.out.println()。print()方法不会产生一个新行，以便在同一行里罗列多种信息。
除展示所有按位运算符针对int和long的效果之外，本例也展示了int和long的最小值、最大值、+1和-1值，使大家能体会它们的情况。注意高位代表正负号：0为正，1为负。下面列出int部分的输出：

1. -1, int: -1, binary:
   
2.    11111111111111111111111111111111
   
3. +1, int: 1, binary:
   
4.    00000000000000000000000000000001
   
5. maxpos, int: 2147483647, binary:
   
6.    01111111111111111111111111111111
   
7. maxneg, int: -2147483648, binary:
   
8.    10000000000000000000000000000000
   
9. i, int: 59081716, binary:
   
10.    00000011100001011000001111110100
    
11. ~i, int: -59081717, binary:
    
12.    11111100011110100111110000001011
    
13. -i, int: -59081716, binary:
    
14.    11111100011110100111110000001100
    
15. j, int: 198850956, binary:
    
16.    00001011110110100011100110001100
    
17. i & j, int: 58720644, binary:
    
18.    00000011100000000000000110000100
    
19. i | j, int: 199212028, binary:
    
20.    00001011110111111011101111111100
    
21. i ^ j, int: 140491384, binary:
    
22.    00001000010111111011101001111000
    
23. i << 5, int: 1890614912, binary:
    
24.    01110000101100000111111010000000
    
25. i >> 5, int: 1846303, binary:
    
26.    00000000000111000010110000011111
    
27. (~i) >> 5, int: -1846304, binary:
    
28.    11111111111000111101001111100000
    
29. i >>> 5, int: 1846303, binary:
    
30.    00000000000111000010110000011111
    
31. (~i) >>> 5, int: 132371424, binary:
    
32.    00000111111000111101001111100000

复制代码

数字的二进制形式表现为“有符号2的补值”。 {:soso_e130:}