出自 http://www.3geye.net/?3/viewspace-3425
這里排版不好可以到原文查看
運 算 符 指 明 對 操 作 數 所 進 行 的 運 算 。 按 操 作 數 的 數 目 來 分 ,可 以 有 一 元 運 算 符 (如 ++、
-),二 元 運 算 符 (如 +、 ＞)和 三 元 運 算 符 (如 ?:),它 們 分 別 對 應 于 一 個 、 兩 個 和 三 個 操 作 數 。 對
于 一 元 運 算 符 來 說 ,可 以 有 前 綴 表 達 式 (如 ++i )和 后 綴 表 達 式 (如 i++),對 于 二 元 運 算 符 來 說 則
采 用 中 綴 表 達 式 (如 a+b)。 按 照 運 算 符 功 能 來 分 ,基 本 的 運 算 符 有 下 面 幾 類 :
1.算 術 運 算 符 (+,-,*,/,%,++,--)
2.關 系 運 算 符 (＞,＜,＞=,＜=,==,!=)
3.布 爾 邏 輯 運 算 符 (!,&&,||)
4.位 運 算 符 (＞＞,＜＜,＞＞＞,&,|,^,～ )
5.賦 值 運 算 符 (=,及 其 擴 展 賦 值 運 算 符 如 +=)
6.條 件 運 算 符 ( ?:)
7.其 它 (包 括 分 量 運 算 符 ? ,下 標 運 算 符 [],實 例 運 算 符 instanc eof,內 存 分 配 運 算 符 new,強 制 類
型 轉 換 運 算 符 (類 型 ),方 法 調 用 運 算 符 () 等 )
本 章 中 我 們 主 要 講 述 前 6類 運 算 符 。
§ 3.1算 術 運 算 符
算 術 運 算 符 作 用 于 整 型 或 浮 點 型 數 據 ,完 成 算 術 運 算 。
一 、 二 元 算 術 運 算 符 ,如 下 表 所 示
運算符 用法 描述
+ op1+op2 加
- op1-op2 減
* op1*op2 乘
/ op1/op2 除
% op1%op2 取模(求余)
Java對 加 運 算 符 進 行 了 擴 展 ,使 它 能 夠 進 行 字 符 串 的 連 接 ,如 "abc"+"de",得 到 串 "abcde"。 我
們 將 在 第 七 章 中 講 解 。
與 C、 C++不 同 ,對 取 模 運 算 符 %來 說 ,其 操 作 數 可 以 為 浮 點 數 , 如 37.2%10=7.2。
二 、 一 元 算 術 運 算 符 ,如 下 表 所 示 :
運算符 用法 描述
+ +op 正值
- -op 負值
++ ++op,op++ 加1
-- --op,op-- 減1
i++與 ++i的 區 別
i++在 使 用 i之 后 ,使 i的 值 加 1,因 此 執 行 完 i++后 ,整 個 表 達 式 的 值 為 i,而 i的 值 變 為 i+1。
++i在 使 用 i之 前 ,使 i的 值 加 1,因 此 執 行 完 ++i后 ,整 個 表 達 式 和 i的 值 均 為 i+1。
對 i--與 --i同 樣 。
例 3.1.下 面 的 例 子 說 明 了 算 術 運 算 符 的 使 用
public class ArithmaticOp{
public static void main( String args[] ){
int a=5+4; //a=9
int b=a*2; //b=18
int c=b/4; //c=4
int d=b-c; //d=14
int e=-d; //e=-14
int f=e%4; //f=-2
double g=18.4;
double h=g%4; //h=2.4
int i=3;
int j=i++; //i=4,j=3
int k=++i; //i=5,k=5
System.out.println("a = "+a);
System.out.println("b = "+b);
System.out.println("c = "+c);
System.out.println("d = "+d);
System.out.println("e = "+e);
System.out.println("f = "+f);
System.out.println("g = "+g);
System.out.println("h = "+h);
System.out.println("i = "+i);
System.out.println("j = "+j);
System.out.println("k = "+k);
}
}
其結果為:
C:\＞java ArithmaticOp
a = 9
b = 18
c = 4
d = 14
e = -14
f = -2
g = 18.4
h = 2.4
i = 5
j = 3
k = 5
§ 3.2關 系 運 算 符
關 系 運 算 符 用 來 比 較 兩 個 值 ,返 回 布 爾 類 型 的 值 true或 false。 關 系 運 算 符 都 是 二 元 運 算
符 ,如 下 表 所 示 :
運算符 用法 返回true的情況
＞ op1＞op2 op1大于op2
＞+ op1＞=op2 op1大于或等于op2
＜ op1＜op2 op1小于op2
＜= op1＜=op2 op1小于或等于op2
== op1==op2 op1與op2相等
!= op1!=op2 op1與op2不等
Java中 ,任 何 數 據 類 型 的 數 據 (包 括 基 本 類 型 和 組 合 類 型 )都 可 以 通 過 ==或 !=來 比 較 是 否
相 等 (這 與 C、 C++不 同 )。
關 系 運 算 的 結 果 返 回 true或 false,而 不 是 C、 C++中 的 1或 0。
關 系 運 算 符 常 與 布 爾 邏 輯 運 算 符 一 起 使 用 ,作 為 流 控 制 語 句 的 判 斷 條 件 。 如
if( a＞b && b==c)
§ 3.3布 爾 邏 輯 運 算 符
布 爾 邏 輯 運 算 符 進 行 布 爾 邏 輯 運 算 ,如 下 表 所 示 :
op1 op2 op1&&op2 op1||op2 !op1
false false false false true
false true false true true
true false false true false
true true true true false
}@@@
?&&、‖
為二元運算符,實現邏輯與、邏輯或。
?! 為一元運算符,實現邏輯非。
?對于布爾邏輯運算,先求出運算符左邊的表達式的值,對或運算如果為true,則整個表
達式的結果為true,不必對運算符右邊的表達式再進行運算;同樣,對與運算,如果左邊表達式
的值為false,則不必對右邊的表達式求值,整個表達式的結果為false。
下面的例子說明了關系運算符和布爾邏輯運算符的使用。
@@@[
public class RelationAndConditionOp{
public static void main( String args[] ){
int a=25,b=3;
boolean d=a＜b; //d=false
System.out.println("a＜b = "+d);
int e=3;
if(e!=0 && a/e＞5)
System.out.println("a/e = "+a/e);
int f=0;
if(f!=0 && a/f＞5)
System.out.println("a/f = "+a/f);
else
System.out.println("f = "+f);
}
}
其運行結果為:
C:\＞java RelationAndConditionOp
a＜b = false
a/e = 8
f = 0
注 意 :上 例 中 ,第 二 個 if語 句 在 運 行 時 不 會 發 生 除 0溢 出 的 錯 誤 ,因 為 e!=0為 false,所 以 就 不 需
要 對 a/e進 行 運 算 。
§ 3.4位 運 算 符
位 運 算 符 用 來 對 二 進 制 位 進 行 操 作 ,Java中 提 供 了 如 下 表 所 示 的 位 運 算 符 :
位 運 算 符 中 ,除
～
以 外 ,其 余 均 為 二 元 運 算 符 。
操 作 數 只 能 為 整 型 和 字 符 型 數 據 。
3.4.1補 碼
Java使 用 補 碼 來 表 示 二 進 制 數 ,在 補 碼 表 示 中 ,最 高 位 為 符 號 位 ,正 數 的 符 號 位 為 0,負 數
為 1。 補 碼 的 規 定 如 下 :
對 正 數 來 說 ,最 高 位 為 0,其 余 各 位 代 表 數 值 本 身 (以 二 進 制 表 示 ),如 +42的 補 碼 為
00101010。
對 負 數 而 言 ,把 該 數 絕 對 值 的 補 碼 按 位 取 反 ,然 后 對 整 個 數 加 1,即 得 該 數 的 補 碼 。 如
-42的 補 碼 為 11010110 (00101010 按 位 取 反 11010101 +1 11010110 )
用 補 碼 來 表 示 數 ,0的 補 碼 是 唯 一 的 ,都 為 00000000。 (而 在 原 碼 ,反 碼 表 示 中 ,+0和 -0的 表 示
是 不 唯 一 的 ,可 參 見 相 應 的 書 籍 )。 而 且 可 以 用 111111表 示 -1的 補 碼 (這 也 是 補 碼 與 原 碼 和 反
碼 的 區 別 )。
3.4.2按 位 取 反 運 算 符
～
～
是 一 元 運 算 法 ,對 數 據 的 每 個 二 進 制 位 取 反 ,即 把 1變 為 0,把 0變 為 1。
例 如 :
0010101
～
1101010
注 意 ,～ 運 算 符 與 - 運 算 符 不 同 ,～ 21≠ -21。
3.4.3按 位 與 運 算 符 &
參 與 運 算 的 兩 個 值 ,如 果 兩 個 相 應 位 都 為 1,則 該 位 的 結 果 為 1,否 則 為 0。 即 :
0 & 0 = 0,0 &1 = 0,1 & 0 = 0,1 & 1 = 1
移位運算符
包括：
“>> 右移”；“<< 左移”；“>>> 無符號右移”
例子：
-5>>3=-1
1111 1111 1111 1111 1111 1111 1111 1011
1111 1111 1111 1111 1111 1111 1111 1111
其結果與 Math.floor((double)-5/(2*2*2)) 完全相同。
-5<<3=-40
1111 1111 1111 1111 1111 1111 1111 1011
1111 1111 1111 1111 1111 1111 1101 1000
其結果與 -5*2*2*2 完全相同。
5>>3=0
0000 0000 0000 0000 0000 0000 0000 0101
0000 0000 0000 0000 0000 0000 0000 0000
其結果與 5/(2*2*2) 完全相同。
5<<3=40
0000 0000 0000 0000 0000 0000 0000 0101
0000 0000 0000 0000 0000 0000 0010 1000
其結果與 5*2*2*2 完全相同。
-5>>>3=536870911
1111 1111 1111 1111 1111 1111 1111 1011
0001 1111 1111 1111 1111 1111 1111 1111
無論正數、負數，它們的右移、左移、無符號右移 32 位都是其本身，比如 -5<<32=-5、-5>>32=-5、-5>>>32=-5。
一個有趣的現象是，把 1 左移 31 位再右移 31 位，其結果為 -1。
0000 0000 0000 0000 0000 0000 0000 0001
1000 0000 0000 0000 0000 0000 0000 0000
1111 1111 1111 1111 1111 1111 1111 1111
Java 定義的位運算（bitwise operators ）直接對整數類型的位進行操作，這些整數類型包括long，int，short，char，and byte 。表4-2 列出了位運算：
運算符 結果
~ 按位非（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
因變量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
};
byte b = (byte) 0xf1;
System.out.println("b = 0x" + hex[(b >> 4) & 0x0f] + hex[b & 0x0f]);}}
該程序的輸出如下：
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);
}
}
該程序的輸出如下所示：