[转]java中char，byte，short的移位操作

在Think in Java中有这么一段话“对char，byte或者short进行移位处理，那么在移位进行之前，它们会自动转换成一个int。只有右侧的5个低位才会有用。这样可防止我们在一个int数里移动不切实际的位数。若对一个long值进行处理，最后得到的结果也是long。此时只会用到右侧的6个低位，防止移动超过long值里现成的位数。”

 

对上面那段话的理解是：移位操作符操作的运算对象是二进制的“位”，int类型是32位也就是2的5次幂 ！如果移32位以上，那么原来的数的信息会全部丢失，这样也就没有什么意义了！所以上面的“只有右侧的5个低位才会有用”说的是：移位操作符右端的那个数（化成二进制）的低5位才有用，即 X < <y;   是指y的低5位才有用，即不能大于32。 而对于long型也是同样的道理！

因此，如果对一个int 型，进行移位，X < <y; 当y小于32时，移位后的结果一般都在我们的预料当中；而如果y大于32时，由于移位超出了int所能表示的范围，这时就先把y化成二进制数，然后取该二进制数右端的低5位（相当于&11111或者是除32得到的余数），再把这5位化成十进制，此时的这个十进制就是要对X移动的位数。

例如：        

                                 int i = 1245;
		String s = Integer.toBinaryString(i);
		int y1 = i>>2;
		String s1 = Integer.toBinaryString(y1);
		int y2 = i>>34;
		String s2 = Integer.toBinaryString(y2);
		System.out.println(i + "->" + s + "  " + y1 + "->" + s1 + "  " + y2 + "->" + s2);

语句“ int y2 = i>>34;”的执行过程是：先把i化成二进制数：10011011101

 执行结果：

1245->10011011101  311->100110111  311->100110111

 

执行语句 i>> 34   对i右移34位时，先把34化成二进制：100010，对该二进制数取右边5位，即00010，化成十进制数为2，所以实际上是对i右移两位。现在，结果是：100110111

 

 

long型数据移位时一样的道理，long型一共64位，如果移动的位数超过64(2^8)就没有意义了，所以在移位前判断移动的位数是否大于64，如果大于了64则取该位数的低8位（除以64得到的余数），再移位，否则直接移位。

移位运算符和按位运算符一样，同属于位运算符，因此移位运算符的位指的也是二进制位。它包括以下几种：
左移位（<<）：将操作符左侧的操作数向左移动操作符右侧指定的位数。移动的规则是在二进制的低位补0。

1. 有符号右移位（>>）：将操作符左侧的操作数向右移动操作符右侧指定的位数。移动的规则是，如果被操作数的符号为正，则在二进制的高位补0；如果被操作数的符号为负，则在二进制的高位补1。
2. 无符号右移位（>>>）：将操作符左侧的操作数向右移动操作符右侧指定的位数。移动的规则是，无论被操作数的符号是正是负，都在二进制位的高位补0。

注意，移位运算符不存在“无符号左移位（<<<）”一说。与按位运算符一样，移位运算符可以用于byte、short、int、long等整数类型，和字符串类型char，但是不能用于浮点数类型float、double；当然，在Java5.0及以上版本中，移位运算符还可用于byte、short、int、long、char对应的包装器类。我们可以参照按位运算符的示例写一个测试程序来验证，这里就不再举例了。
与按位运算符不同的是，移位运算符不存在短路不短路的问题。
写到这里就不得不提及一个在面试题中经常被考到的题目：

引用

请用最有效率的方法计算出2乘以8等于几？

这里所谓的最有效率，实际上就是通过最少、最简单的运算得出想要的结果，而移位是计算机中相当基础的运算了，用它来实现准没错了。左移位“<<”把被操作数每向左移动一位，效果等同于将被操作数乘以2，同理，无符号右移位">>>"把被操作数每向右移动一位，效果等同于将被操作数除以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。

下面的测试代码验证了以上的规律：

Java代码  

1. public abstract class Test {   
2.     public static void 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. 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

转自：http://blog.csdn.net/chattie/archive/2009/03/27/4029922.aspx