移位操作符也操纵二进制位，它们只能用来处理基本类型里的整数类型。左移位操作符（<<）会将操作符左侧的操作数向左移动，移动的位数在操作符右侧指定（低位补 0）。“有符号” 的右移位操作符（>>）则按照操作符右侧指定的位数将操作符左侧的操作数向右移动。“有符号” 的右移位操作符使用了 “符号扩展”：如果符号为正，则在高位插入 0，否则在高位插入 1。Java 还新增加了一种 “无符号” 的右移位操作符（>>>），它使用 “零扩展”：无论符号为正还是为负，都在高位插入 0。这一操作符是 C 或 C++ 中所没有的。

    如果对 char、byte 或者 short 类型的数值进行移位运算，在移位操作前它们会被转换为 int 类型，并且结果也是 int 类型。右端的可移位数中只会用到低 5 位。这样可防止我们移位超过 int 型值所具有的位数。如果处理的是 long 类型，最后得到的结果也是 long 类型。此时只会用到右端指定移位数值的低 6 位，这样移位操作就不会超出 long 类型的最大位数。

    移位操作符可以与等号组合使用（ <<=、>>= 或 >>>= ）。操作符左边的值会移动右边指定的位数，然后再将得到的结果赋给左边的变量。但 “无符号” 右移位操作符结合赋值操作符可能会遇到一个问题：如果对 byte 或 short 值进行移位运算，得到的可能不是正确的结果。它们会先被提升为 int 类型，进行右移操作，然后在被赋回给原来的变量时被截断，这时得到结果是 -1。下面是一个示例：

    1. // operators/URShift.java
    2. // 无符号右移测试
    4. public class URShift {
    5.   public static void main(String[] args) {
    6.     int i = -1;
    7.     System.out.println(Integer.toBinaryString(i));
    8.     i >>>= 10;
    9.     System.out.println(Integer.toBinaryString(i));
    10.     long l = -1;
    11.     System.out.println(Long.toBinaryString(l));
    12.     l >>>= 10;
    13.     System.out.println(Long.toBinaryString(l));
    14.     short s = -1;
    15.     System.out.println(Integer.toBinaryString(s));
    16.     s >>>= 10;
    17.     System.out.println(Integer.toBinaryString(s));
    18.     byte b = -1;
    19.     System.out.println(Integer.toBinaryString(b));
    20.     b >>>= 10;
    21.     System.out.println(Integer.toBinaryString(b));
    22.     b = -1;
    23.     System.out.println(Integer.toBinaryString(b));
    24.     System.out.println(Integer.toBinaryString(b>>>10));
    25.   }
    26. }
    27. /* 输出:
    28. 11111111111111111111111111111111
    29. 1111111111111111111111
    30. 1111111111111111111111111111111111111111111111111111111111111111
    31. 111111111111111111111111111111111111111111111111111111
    32. 11111111111111111111111111111111
    33. 11111111111111111111111111111111
    34. 11111111111111111111111111111111
    35. 11111111111111111111111111111111
    36. 11111111111111111111111111111111
    37. 1111111111111111111111
    38. */

    在最后一个移位运算中，结果没有赋回给 b，而是直接打印了出来，所以是正确的。
    下面这个示例演示了所有涉及位操作的操作符：

    1. // operators/BitManipulation.java
    2. // 使用按位操作符
    3. import java.util.*;
    5. public class BitManipulation {
    6.   public static void main(String[] args) {
    7.     Random rand = new Random(47);
    8.     int i = rand.nextInt();
    9.     int j = rand.nextInt();
    10.     printBinaryInt("-1", -1);
    11.     printBinaryInt("+1", +1);
    12.     int maxpos = 2147483647;
    13.     printBinaryInt("maxpos", maxpos);
    14.     int maxneg = -2147483648;
    15.     printBinaryInt("maxneg", maxneg);
    16.     printBinaryInt("i", i);
    17.     printBinaryInt("~i", ~i);
    18.     printBinaryInt("-i", -i);
    19.     printBinaryInt("j", j);
    20.     printBinaryInt("i & j", i & j);
    21.     printBinaryInt("i | j", i | j);
    22.     printBinaryInt("i ^ j", i ^ j);
    23.     printBinaryInt("i << 5", i << 5);
    24.     printBinaryInt("i >> 5", i >> 5);
    25.     printBinaryInt("(~i) >> 5", (~i) >> 5);
    26.     printBinaryInt("i >>> 5", i >>> 5);
    27.     printBinaryInt("(~i) >>> 5", (~i) >>> 5);
    29.     long l = rand.nextLong();
    30.     long m = rand.nextLong();
    31.     printBinaryLong("-1L", -1L);
    32.     printBinaryLong("+1L", +1L);
    33.     long ll = 9223372036854775807L;
    34.     printBinaryLong("maxpos", ll);
    35.     long lln = -9223372036854775808L;
    36.     printBinaryLong("maxneg", lln);
    37.     printBinaryLong("l", l);
    38.     printBinaryLong("~l", ~l);
    39.     printBinaryLong("-l", -l);
    40.     printBinaryLong("m", m);
    41.     printBinaryLong("l & m", l & m);
    42.     printBinaryLong("l | m", l | m);
    43.     printBinaryLong("l ^ m", l ^ m);
    44.     printBinaryLong("l << 5", l << 5);
    45.     printBinaryLong("l >> 5", l >> 5);
    46.     printBinaryLong("(~l) >> 5", (~l) >> 5);
    47.     printBinaryLong("l >>> 5", l >>> 5);
    48.     printBinaryLong("(~l) >>> 5", (~l) >>> 5);
    49.   }
    50.   static void printBinaryInt(String s, int i) {
    51.     System.out.println(
    52.       s + ", int: " + i + ", binary:\n   " +
    53.       Integer.toBinaryString(i));
    54.   }
    55.   static void printBinaryLong(String s, long l) {
    56.     System.out.println(
    57.       s + ", long: " + l + ", binary:\n    " +
    58.       Long.toBinaryString(l));
    59.   }
    60. }
    61. /* 输出（前32行）：
    62. -1, int: -1, binary:
    63.    11111111111111111111111111111111
    64. +1, int: 1, binary:
    65.    1
    66. maxpos, int: 2147483647, binary:
    67.    1111111111111111111111111111111
    68. maxneg, int: -2147483648, binary:
    69.    10000000000000000000000000000000
    70. i, int: -1172028779, binary:
    71.    10111010001001000100001010010101
    72. ~i, int: 1172028778, binary:
    73.    1000101110110111011110101101010
    74. -i, int: 1172028779, binary:
    75.    1000101110110111011110101101011
    76. j, int: 1717241110, binary:
    77.    1100110010110110000010100010110
    78. i & j, int: 570425364, binary:
    79.    100010000000000000000000010100
    80. i | j, int: -25213033, binary:
    81.    11111110011111110100011110010111
    82. i ^ j, int: -595638397, binary:
    83.    11011100011111110100011110000011
    84. i << 5, int: 1149784736, binary:
    85.    1000100100010000101001010100000
    86. i >> 5, int: -36625900, binary:
    87.    11111101110100010010001000010100
    88. (~i) >> 5, int: 36625899, binary:
    89.    10001011101101110111101011
    90. i >>> 5, int: 97591828, binary:
    91.    101110100010010001000010100
    92. (~i) >>> 5, int: 36625899, binary:
    93.    10001011101101110111101011
    94.                   ...
    95. */

    程序末尾有两个方法：printBinaryInt() 和 printBinaryLong()。它们分别接受 int 类型和 long 类型的参数，然后输出其二进制格式，并附有说明文字。上面的示例不但演示了 int 和 long 的所有按位操作，还展示了 int 和 long 的最小值、最大值、正 1 值和负 1 值的二进制形式，这样你就可以了解它们大概的样子。注意最高位表示符号：0 表示正，1 表示负。可以参考上面示例中int部分的输出。
    数字的二进制表示形式被称为 “有符号的二进制补码”。