JAVA的位运算

JAVA的位运算

关键字: java 位运算

Java 位运算        

一，Java 位运算

1.表示方法：

　在Java语言中，二进制数使用补码表示，最高位为符号位，正数的符号位为0，负数为1。补码的表示需要满足如下要求。
(l)正数的最高位为0，其余各位代表数值本身(二进制数)。
(2)对于负数，通过对该数绝对值的补码按位取反，再对整个数加1。

2.位运算符
位运算表达式由操作数和位运算符组成，实现对整数类型的二进制数进行位运算。位运算符可以分为逻辑运算符(包括~、＆、|和^)及移位运算符(包括>>、<<和>>>)。

注释:~

～是取反运算

首先，你要知道java中的int是32位的

其次，正数以原码的形式存储，负数以补码的形式存储

4的二进制是0000 0000 0000 0000 0000 0000 0000 0100

取反后得1111 1111 1111 1111 1111 1111 1111 1011

java中都是有符号数，首位是1，所以是负数，负数也就是补码，也就是说

1111 1111 1111 1111 1111 1111 1111 1011是补码

补码，反码加1后得源码

转换成源码得0000 0000 0000 0000 0000 0000 0000 0101

这个数是5，加上符号就是-5

1)左移位运算符（<<）能将运算符左边的运算对象向左移动运算符右侧指定的位数（在低位补0）。
2)“有符号”右移位运算符（>>）则将运算符左边的运算对象向右移动运算符右侧指定的位数。
“有符号”右移位运算符使用了“符号扩展”：若值为正，则在高位插入0；若值为负，则在高位插入1。

3)Java也添加了一种“无符号”右移位运算符（>>>），它使用了“零扩展”：无论正负，都在高位插入0。这一运算符是C或C++没有的。

4)若对char，byte或者short进行移位处理，那么在移位进行之前，它们会自动转换成一个int。
只有右侧的5个低位才会用到。这样可防止我们在一个int数里移动不切实际的位数。
若对一个long值进行处理，最后得到的结果也是long。此时只会用到右侧的6个低位，防止移动超过long值里现成的位数。
但在进行“无符号”右移位时，也可能遇到一个问题。若对byte或short值进行右移位运算，得到的可能不是正确的结果（Java 1.0和Java 1.1特别突出）。
它们会自动转换成int类型，并进行右移位。但“零扩展”不会发生，所以在那些情况下会得到-1的结果。

在进行位运算时，需要注意以下几点。
(1)>>>和>>的区别是：在执行运算时，>>>运算符的操作数高位补0，而>>运算符的操作数高位移入原来高位的值。
(2)右移一位相当于除以2，左移一位(在不溢出的情况下)相当于乘以2；移位运算速度高于乘除运算。
(3)若进行位逻辑运算的两个操作数的数据长度不相同，则返回值应该是数据长度较长的数据类型。
(4)按位异或可以不使用临时变量完成两个值的交换，也可以使某个整型数的特定位的值翻转。
(5)按位与运算可以用来屏蔽特定的位，也可以用来取某个数型数中某些特定的位。
(6)按位或运算可以用来对某个整型数的特定位的值置l。

3．位运算符的优先级
~的优先级最高，其次是<<、>>和>>>，再次是＆，然后是^，优先级最低的是|。

二， 按位异或运算符^

参与运算的两个值，如果两个相应位相同，则结果为0，否则为1。即：0^0=0， 1^0=1， 0^1=1， 1^1=0

例如：10100001^00010001=10110000

0^0=0,0^1=1 0异或任何数＝任何数

1^0=1,1^1=0 1异或任何数－任何数取反

任何数异或自己＝把自己置0

(1)按位异或可以用来使某些特定的位翻转，如对数10100001的第2位和第3位翻转，可以将数与00000110进行按位异或运算。

　　　　　　　　　 10100001^00000110=10100111 //1010 0001 ^ 0x06 = 1010 0001 ^ 6

(2)通过按位异或运算，可以实现两个值的交换，而不必使用临时变量。例如交换两个整数a，b的值，可通过下列语句实现：

    a=10100001,b=00000110

    a=a^b； 　　//a=10100111

    b=b^a； 　　//b=10100001

    a=a^b； 　　//a=00000110

(3)异或运算符的特点是：数a两次异或同一个数b（a=a^b^b）仍然为原值a.

三，Java 中除了二进制的表示方法：

由于数据在计算机中的表示，最终以二进制的形式存在，所以有时候使用二进制，可以更直观地解决问题。 

但，二进制数太长了。比如int   类型占用4个字节，32位。比如100，用int类型的二进制数表达将是： 

0000   0000   0000   0000   0110   0100 

面对这么长的数进行思考或操作，没有人会喜欢。因此，C,C++,以及java中   没有提供在代码直接写二进制数的方法。 

八进制数的表达方法 

如何表达一个八进制数呢？如果这个数是   876,我们可以断定它不是八进制数，因为八进制数中不可能出7以上的阿拉伯数字。但如果这个数是123、是567，或12345670，那么它是八进制数还是10进制数，都有可能。 

所以规定，一个数如果要指明它采用八进制，必须在它前面加上一个0，如：123是十进制，但0123则表示采用八进制。这就是八进制数的表达方法。 


现在，对于同样一个数，比如是100，我们在代码中可以用平常的10进制表达，例如在变量初始化时： 

int   a   =   100; 

我们也可以这样写： 

int   a   =   0144;   //0144是八进制的100；一个10进制数如何转成8进制。 

千万记住，用八进制表达时，你不能少了最前的那个0。否则计算机会通通当成10进制。不过，有一个地方使用八进制数时，却不能使用加0，那就是我们前面学的用于表达字符的“转义符”表达法。 

十六进制数的表达方法 

如果不使用特殊的书写形式，16进制数也会和10进制相混。随便一个数：9876，就看不出它是16进制或10进制。 

16进制数必须以   0x开头。比如   0x1表示一个16进制数。而1则表示一个十进制。另外如：0xff,0xFF,0X102A,等等。其中的x也也不区分大小写。(注意：0x中的0是数字0，而不是字母O) 

以下是一些用法示例： 


int   a   =   0x100F; 

int   b   =   0x70   +   a; 

最后一点很重要，10进制数有正负之分，比如12表示正12，而-12表示负 12，；但8进制和16进制只能用达无符号的正整数，如果你在代码中里：-078，或者写：-0xF2,编译器并不把它当成一个负数。

  /* 位运算
* java使用补码来表示2进制数,最高位为符号位,正数为0,负数为1,补码规定:
* 整数,最高位是0,其余是本身,如 +42的补 码 为 00101010
* 负数,最高位是1,将其余的决定值按位取反,最后+1,即为负数的补码;
* 如 -42的 补 码 为 11010110 (00101010 按位 取 反 11010101 +1=11010110 )
********
*逻辑运算*
********
a&b 与门[真真为真,真假为假]
0000 0000 0000 0000 0000 0000 0000 0001
0000 0000 0000 0000 0000 0000 0000 0010
=
0000 0000 0000 0000 0000 0000 0000 0000
System.out.println(1 & 2);
结果为0
a|b 或门[假假为假,其余全真]
0000 0000 0000 0000 0000 0000 0000 0001
0000 0000 0000 0000 0000 0000 0000 0010
=
0000 0000 0000 0000 0000 0000 0000 0011
System.out.println(1 | 2);
结果为3
~a 非门[真则假,假则真]
0000 0000 0000 0000 0000 0000 0000 0001
=
1111 1111 1111 1111 1111 1111 1111 1110
System.out.println(~1);
结果为:-2
a^b 异或门: [相同为假,不同为真]
0000 0000 0000 0000 0000 0000 0000 0001
0000 0000 0000 0000 0000 0000 0000 0010
=
0000 0000 0000 0000 0000 0000 0000 0011
System.out.println(1^2);
结果为 3
********
*移位运算*
********
a>>b 有符号右移位;将a右移b位;若正数,高位补0,负数,高位补1
0000 0000 0000 0000 0000 0000 0000 0011
>>1
=
0000 0000 0000 0000 0000 0000 0000 0001
System.out.println(3>>1);
结果为1,结果与 3 / 2的1次幂相同
   a<<b 有符号左移位;将a左移b位,若正数,高位补0,负数,高位补1
0000 0000 0000 0000 0000 0000 0000 0011
<<2
0000 0000 0000 0000 0000 0000 0000 1100
System.out.println(3<<2);
结果为12,与3*2的2次幂相同
a>>>b 无符号右移位;将a左移b位,不论正负,高位均补0
0000 0000 0000 0000 0000 0000 0000 0011
>>1
=
0000 0000 0000 0000 0000 0000 0000 0001
System.out.println(3>>>1);
结果为1,与3/2的1次幂相同
*/
System.out.println(3>>>1);
System.out.println();

Java 定义的位运算（bitwise operators ）直接对整数类型的位进行操作，这些整数类型包括long，int，short，char，and byte 。

运算符 结果
~ 按位非（NOT）（一元运算）
& 按位与（AND）
| 按位或（OR）
^ 按位异或（XOR）
>> 右移
>>> 右移，左边空出的位以0填充
运算符 结果
<< 左移
&= 按位与赋值
|= 按位或赋值
^= 按位异或赋值
>>= 右移赋值
>>>= 右移赋值，左边空出的位以0填充
<<= 左移赋值

既然位运算符在整数范围内对位操作，因此理解这样的操作会对一个值产生什么效果是重要的。具体地说，知道Java 是如何存储整数值并且如何表示负数的是有用的。因此，在继续讨论之前，让我们简短概述一下这两个话题。

所 有的整数类型以二进制数字位的变化及其宽度来表示。例如，byte 型值42的二进制代码是00101010 ，其中每个位置在此代表2的次方，在最右边的位以20开始。向左下一个位置将是21，或2，依次向左是22，或4，然后是8，16，32等等，依此类推。 因此42在其位置1，3，5的值为1（从右边以0开始数）；这样42是21+23+25的和，也即是2+8+32 。

所有的整数类型 （除了char 类型之外）都是有符号的整数。这意味着他们既能表示正数，又能表示负数。Java 使用大家知道的2的补码（two’s complement ）这种编码来表示负数，也就是通过将与其对应的正数的二进制代码取反（即将1变成0，将0变成1），然后对其结果加1。例如，-42就是通过将42的二进 制代码的各个位取反，即对00101010 取反得到11010101 ，然后再加1，得到11010110 ，即-42 。要对一个负数解码，首先对其所有的位取反，然后加1。例如-42，或11010110 取反后为00101001 ，或41，然后加1，这样就得到了42。

如果考虑到零的交叉（zero crossing ）问题，你就容易理解Java （以及其他绝大多数语言）这样用2的补码的原因。假定byte 类型的值零用00000000 代表。它的补码是仅仅将它的每一位取反，即生成11111111 ，它代表负零。但问题是负零在整数数学中是无效的。为了解决负零的问题，在使用2的补码代表负数的值时，对其值加1。即负零11111111 加1后为100000000 。但这样使1位太靠左而不适合返回到byte 类型的值，因此人们规定，-0和0的表示方法一样，-1的解码为11111111 。尽管我们在这个例子使用了byte 类型的值，但同样的基本的原则也适用于所有Java 的整数类型。

因为Java 使用2的补码来存储负数，并且因为Java 中的所有整数都是有符号的，这样应用位运算符可以容易地达到意想不到的结果。例如，不管你如何打算，Java 用高位来代表负数。为避免这个讨厌的意外，请记住不管高位的顺序如何，它决定一个整数的符号。

4.2.1 位逻辑运算符
位逻辑运算符有“与”（AND）、“或”（OR）、“异或（XOR ）”、“非（NOT）”，分别用“&”、“|”、“^”、“~”表示，4-3 表显示了每个位逻辑运算的结果。在继续讨论之前，请记住位运算符应用于每个运算数内的每个单独的位。
表4-3 位逻辑运算符的结果
A 0 1 0 1 B 0 0 1 1 A | B 0 1 1 1 A & B 0 0 0 1 A ^ B 0 1 1 0 ~A 1 0 1 0

按位非（NOT）

按位非也叫做补，一元运算符NOT“~”是对其运算数的每一位取反。例如，数字42，它的二进制代码为：

00101010

经过按位非运算成为

11010101

按位与（AND）

按位与运算符“&”，如果两个运算数都是1，则结果为1。其他情况下，结果均为零。看下面的例子：

00101010 42 &00001111 15

00001010 10

按位或（OR）

按位或运算符“|”，任何一个运算数为1，则结果为1。如下面的例子所示：

00101010 42 | 00001111 15

00101111 47

按位异或（XOR）

按 位异或运算符“^”，只有在两个比较的位不同时其结果是 1。否则，结果是零。下面的例子显示了“^”运算符的效果。这个例子也表明了XOR 运算符的一个有用的属性。注意第二个运算数有数字1的位，42对应二进制代码的对应位是如何被转换的。第二个运算数有数字0的位，第一个运算数对应位的数 字不变。当对某些类型进行位运算时，你将会看到这个属性的用处。

00101010 42 ^ 00001111 15

00100101 37
位逻辑运算符的应用

下面的例子说明了位逻辑运算符：

// Demonstrate the bitwise logical operators.
class BitLogic {
public static void main(String args[]) {


String binary[] = {"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"

};
int a = 3; // 0 + 2 + 1 or 0011 in binary
int b = 6; // 4 + 2 + 0 or 0110 in binary
int c = a | b;
int d = a & b;
int e = a ^ b;
int f = (~a & b) | (a & ~b);
int g = ~a & 0x0f;


System.out.println(" a = " + binary[a]);
System.out.println(" b = " + binary);
System.out.println(" a|b = " + binary[c]);
System.out.println(" a&b = " + binary[d]);
System.out.println(" a^b = " + binary[e]);
System.out.println("~a&b|a&~b = " + binary[f]);
System.out.println(" ~a = " + binary[g]);


}
}


在 本例中，变量a与b对应位的组合代表了二进制数所有的 4 种组合模式：0-0，0-1，1-0 ，和1-1 。“|”运算符和“&”运算符分别对变量a与b各个对应位的运算得到了变量c和变量d的值。对变量e和f的赋值说明了“^”运算符的功能。字符串 数组binary 代表了0到15 对应的二进制的值。在本例中，数组各元素的排列顺序显示了变量对应值的二进制代码。数组之所以这样构造是因为变量的值n对应的二进制代码可以被正确的存储 在数组对应元素binary[n] 中。例如变量a的值为3，则它的二进制代码对应地存储在数组元素binary[3] 中。~a的值与数字0x0f （对应二进制为0000 1111 ）进行按位与运算的目的是减小~a的值，保证变量g的结果小于16。因此该程序的运行结果可以用数组binary 对应的元素来表示。该程序的输出如下：

a = 0011 b = 0110 a|b = 0111 a&b = 0010 a^b = 0101 ~a&b|a&~b = 0101 ~a = 1100

4.2.2 左移运算符
左移运算符<<使指定值的所有位都左移规定的次数。它的通用格式如下所示：

value << num
这 里，num 指定要移位值value 移动的位数。也就是，左移运算符<<使指定值的所有位都左移num位。每左移一个位，高阶位都被移出（并且丢弃），并用0填充右边。这意味着 当左移的运算数是int 类型时，每移动1位它的第31位就要被移出并且丢弃；当左移的运算数是long 类型时，每移动1位它的第63位就要被移出并且丢弃。

在对byte 和short类型的值进行移位运算时，你必须小心。因为你知道Java 在对表达式求值时，将自动把这些类型扩大为 int 型，而且，表达式的值也是int 型。对byte 和short类型的值进行移位运算的结果是int 型，而且如果左移不超过31位，原来对应各位的值也不会丢弃。但是，如果你对一个负的byte 或者short类型的值进行移位运算，它被扩大为int 型后，它的符号也被扩展。这样，整数值结果的高位就会被1填充。因此，为了得到正确的结果，你就要舍弃得到结果的高位。这样做的最简单办法是将结果转换为 byte 型。下面的程序说明了这一点：

// Left shifting a byte value.
class ByteShift {


public static void main(String args[]) {
byte a = 64, b;
int i;


i = a << 2;
b = (byte) (a << 2);


System.out.println("Original value of a: " + a);
System.out.println("i and b: " + i + " " + b);
}
}


该程序产生的输出下所示：

Original value of a: 64
i and b: 256 0


因变量a在赋值表达式中，故被扩大为int 型，64（0100 0000 ）被左移两次生成值256 （10000 0000 ）被赋给变量i。然而，经过左移后，变量b中惟一的1被移出，低位全部成了0，因此b的值也变成了0。

既然每次左移都可以使原来的操作数翻倍，程序员们经常使用这个办法来进行快速的2 的乘法。但是你要小心，如果你将1移进高阶位（31或63位），那么该值将变为负值。下面的程序说明了这一点：

// Left shifting as a quick way to multiply by 2.
class MultByTwo {


public static void main(String args[]) {
int i;
int num = 0xFFFFFFE;


for(i=0; i<4; i++) {
num = num << 1;
System.out.println(num);


}
}
这 里，num 指定要移位值value 移动的位数。也就是，左移运算符<<使指定值的所有位都左移num位。每左移一个位，高阶位都被移出（并且丢弃），并用0填充右边。这意味着 当左移的运算数是int 类型时，每移动1位它的第31位就要被移出并且丢弃；当左移的运算数是long 类型时，每移动1位它的第63位就要被移出并且丢弃。

在对byte 和short类型的值进行移位运算时，你必须小心。因为你知道Java 在对表达式求值时，将自动把这些类型扩大为 int 型，而且，表达式的值也是int 型。对byte 和short类型的值进行移位运算的结果是int 型，而且如果左移不超过31位，原来对应各位的值也不会丢弃。但是，如果你对一个负的byte 或者short类型的值进行移位运算，它被扩大为int 型后，它的符号也被扩展。这样，整数值结果的高位就会被1填充。因此，为了得到正确的结果，你就要舍弃得到结果的高位。这样做的最简单办法是将结果转换为 byte 型。下面的程序说明了这一点：

// Left shifting a byte value.
class ByteShift {


public static void main(String args[]) {
byte a = 64, b;
int i;


i = a << 2;
b = (byte) (a << 2);


System.out.println("Original value of a: " + a);
System.out.println("i and b: " + i + " " + b);
}
}


该程序产生的输出下所示：

Original value of a: 64
i and b: 256 0


因变量a在赋值表达式中，故被扩大为int 型，64（0100 0000 ）被左移两次生成值256 （10000 0000 ）被赋给变量i。然而，经过左移后，变量b中惟一的1被移出，低位全部成了0，因此b的值也变成了0。

既然每次左移都可以使原来的操作数翻倍，程序员们经常使用这个办法来进行快速的2 的乘法。但是你要小心，如果你将1移进高阶位（31或63位），那么该值将变为负值。下面的程序说明了这一点：

// Left shifting as a quick way to multiply by 2.
class MultByTwo {


public static void main(String args[]) {
int i;
int num = 0xFFFFFFE;


for(i=0; i<4; i++) {
num = num << 1;
System.out.println(num);


}
}
}

该程序的输出如下所示：

536870908
1073741816
2147483632
-32


初值经过仔细选择，以便在左移 4 位后，它会产生-32。正如你看到的，当1被移进31 位时，数字被解释为负值。

4.2.3 右移运算符
右移运算符>>使指定值的所有位都右移规定的次数。它的通用格式如下所示：

value >> num

这里，num 指定要移位值value 移动的位数。也就是，右移运算符>>使指定值的所有位都右移num位。下面的程序片段将值32右移2次，将结果8赋给变量a:

int a = 32;
a = a >> 2; // a now contains 8


当值中的某些位被“移出”时，这些位的值将丢弃。例如，下面的程序片段将35右移2 次，它的2个低位被移出丢弃，也将结果8赋给变量a:

int a = 35;
a = a >> 2; // a still contains 8


用二进制表示该过程可以更清楚地看到程序的运行过程：

00100011 35
>> 2
00001000 8


将值每右移一次，就相当于将该值除以2并且舍弃了余数。你可以利用这个特点将一个整数进行快速的2的除法。当然，你一定要确保你不会将该数原有的任何一位移出。

右 移时，被移走的最高位（最左边的位）由原来最高位的数字补充。例如，如果要移走的值为负数，每一次右移都在左边补1，如果要移走的值为正数，每一次右移都 在左边补0，这叫做符号位扩展（保留符号位）（sign extension ），在进行右移操作时用来保持负数的符号。例如，–8 >> 1 是–4，用二进制表示如下：

11111000 –8 >>1 11111100 –4

一个要注意的有趣问题是，由于符号位扩展（保留符号位）每次都会在高位补1，因此-1右移的结果总是–1。有时你不希望在右移时保留符号。例如，下面的例子将一个byte 型的值转换为用十六
进制表示。注意右移后的值与0x0f进行按位与运算，这样可以舍弃任何的符号位扩展，以便得到的值可以作为定义数组的下标，从而得到对应数组元素代表的十六进制字符。

// Masking sign extension.
class HexByte {
static public void main(String args[]) {


char hex[] = {
’0’, ’1’, ’2’, ’3’, ’4’, ’5’, ’6’, ’7’,
’8’, ’9’, ’a’, ’b’, ’c’, ’d’, ’e’, ’f’’


};
byte b = (byte) 0xf1;


System.out.println("b = 0x" + hex[(b >> 4) & 0x0f] + hex[b & 0x0f]);}}

该程序的输出如下：

b = 0xf1

4.2.4 无符号右移
正 如上面刚刚看到的，每一次右移，>>运算符总是自动地用它的先前最高位的内容补它的最高位。这样做保留了原值的符号。但有时这并不是我们想要 的。例如，如果你进行移位操作的运算数不是数字值，你就不希望进行符号位扩展（保留符号位）。当你处理像素值或图形时，这种情况是相当普遍的。在这种情况 下，不管运算数的初值是什么，你希望移位后总是在高位（最左边）补0。这就是人们所说的无符号移动（unsigned shift ）。这时你可以使用Java 的无符号右移运算符>>> ，它总是在左边补0。

下面的程序段说明了无符号右移运算符>>> 。在本例中，变量a被赋值为-1，用二进制表示就是32位全是1。这个值然后被无符号右移24位，当然它忽略了符号位扩展，在它的左边总是补0。这样得到的值255被赋给变量a。

int a = -1; a = a >>> 24;

下面用二进制形式进一步说明该操作：

11111111 11111111 11111111 11111111 int型-1的二进制代码>>> 24 无符号右移24位00000000 00000000 00000000 11111111 int型255的二进制代码

由 于无符号右移运算符>>> 只是对32位和64位的值有意义，所以它并不像你想象的那样有用。因为你要记住，在表达式中过小的值总是被自动扩大为int 型。这意味着符号位扩展和移动总是发生在32位而不是8位或16位。这样，对第7位以0开始的byte 型的值进行无符号移动是不可能的，因为在实际移动运算时，是对扩大后的32位值进行操作。下面的例子说明了这一点：

// Unsigned shifting a byte value.
class ByteUShift {
static public void main(String args[]) {
进制表示。注意右移后的值与0x0f进行按位与运算，这样可以舍弃任何的符号位扩展，以便得到的值可以作为定义数组的下标，从而得到对应数组元素代表的十六进制字符。

// Masking sign extension.
class HexByte {
static public void main(String args[]) {


char hex[] = {
’0’, ’1’, ’2’, ’3’, ’4’, ’5’, ’6’, ’7’,
’8’, ’9’, ’a’, ’b’, ’c’, ’d’, ’e’, ’f’’


};
byte b = (byte) 0xf1;


System.out.println("b = 0x" + hex[(b >> 4) & 0x0f] + hex[b & 0x0f]);}}

该程序的输出如下：

b = 0xf1

4.2.4 无符号右移
正 如上面刚刚看到的，每一次右移，>>运算符总是自动地用它的先前最高位的内容补它的最高位。这样做保留了原值的符号。但有时这并不是我们想要 的。例如，如果你进行移位操作的运算数不是数字值，你就不希望进行符号位扩展（保留符号位）。当你处理像素值或图形时，这种情况是相当普遍的。在这种情况 下，不管运算数的初值是什么，你希望移位后总是在高位（最左边）补0。这就是人们所说的无符号移动（unsigned shift ）。这时你可以使用Java 的无符号右移运算符>>> ，它总是在左边补0。

下面的程序段说明了无符号右移运算符>>> 。在本例中，变量a被赋值为-1，用二进制表示就是32位全是1。这个值然后被无符号右移24位，当然它忽略了符号位扩展，在它的左边总是补0。这样得到的值255被赋给变量a。

int a = -1; a = a >>> 24;

下面用二进制形式进一步说明该操作：

11111111 11111111 11111111 11111111 int型-1的二进制代码>>> 24 无符号右移24位00000000 00000000 00000000 11111111 int型255的二进制代码

由 于无符号右移运算符>>> 只是对32位和64位的值有意义，所以它并不像你想象的那样有用。因为你要记住，在表达式中过小的值总是被自动扩大为int 型。这意味着符号位扩展和移动总是发生在32位而不是8位或16位。这样，对第7位以0开始的byte 型的值进行无符号移动是不可能的，因为在实际移动运算时，是对扩大后的32位值进行操作。下面的例子说明了这一点：

// Unsigned shifting a byte value.
class ByteUShift {
static public void main(String args[]) {
int b = 2;
int c = 3;


a |= 4;
b >>= 1;
c <<= 1;
a ^= c;
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);


}
}


该程序的输出如下所示：

a = 3
b = 1
c = 6