4.1　Java中的運算符列表

先讓我們了解一下Java的所有運算符號，再展開來講。Java的運算符分為四類：算術運算符、關系運算符、邏輯運算符、位運算符。

·　算術運算符號：+（加）、-（減）、*（乘）、/（除）、%（取模）、++（自加）、--（自減）。

·　關系運算符：==（等于）、!=（不等于）、>（大于）、>=（大于等于）、<（小于）、<=（小于等于）。

·　邏輯運算符：&&（短路與）、||（短路或）、!（非）、^（異或）、&（與）、|（或）。

·　位運算符：&（與）、|（或）、~（按位取反）、>>（右位移）、<<（左位移）、>>>（無符號位移）。

4.1.1　算術運算符

+（加）運算符可以對數值類型進行操作，相加的結果至少為int類型或是較大一方的數據類型。

以下是一些加運算的例子。

【文件4.1】Operation.java

1.　byte a1 = 1;
2.　short a2 = 1;
3.　int a3 = 1;
4.　double a4 = 1D;
5.　// 相加的結果為int類型，所以將a1+a2的結果轉成byte類型
6.　byte b1 = (byte) (a1 + a2);
7.　//相加的結果為short類型，所以將a1+a2的結果轉成short類型
8.　short b2 = (short)(a1+a2);
9.　//相加的結果為int類型，可以直接賦值給int類型
10.　int b3= a1+a2;
11.　//相加的結果為double類型，所以賦值給double類型是可以的
12.　double b4 = a1+a4;

-（減）、*（乘）、/（除）的運算與上面的類似，不再贅述。需要說明的是/（除）運算，如果參與的都是int或long類型，則只會返回整數部分。只有float和double參與運算時，才會返回小數。

1.　int a1 = 10/4;//返回的結果為2
2.　double a2=10.0D/4;//返回2.5

+（運算）不僅可以進行數值的運算，還可以進行字符串的串聯操作，使用+對任意對象進行+操作時，將按優先級將這個對象轉成String。相加的結果也同樣為String類型。

【文件4.2】Operation1.java

1.　int a1 = 10;
2.　int a2 = 90;
3.　String str = "Mrchi";
4.　String str1 = a1+a2+str;
5.　String str2 = str+a1+a2;

在上面的代碼中，第4行相加的結果為100Mrchi。按照運算的優先級，先計算10+90的結果（100）再與Mrchi進行字符串串聯，結果為100Mrchi。

第5行的結果為Mrchi1090。因為先進行Mrchi與10的串聯，成為字符串，再串聯a2，結果為Mrchi1090。

采用%取余（取模）運算符，兩數計算的結果為余數。

【文件4.3】Operation2.java

1.　int a = 10%2;//余數為0，整除
2.　int b = 10%4;//余數為2，即10除以4余2
3.　int c = 10%7;//余數為3

++（自加）分前++、后++。前++是指先加再用，后++是指先用當前的數再進行++操作。--（自減）同上。以下是示例：

【文件4.4】Operation3.java

1.　int a = 1;
2.　int b = a++;
3.　//先將a的值賦給b，所以b的值為1，然后a做自加，所以a的值為2
4.　int c = 1;
5.　int d = ++c;
6.　//先對c做自加操作，此時c的值為2，再將c的值賦給d，所以d的值為2

需要說明的是，++、--操作不會修改數據的類型。例如，以下兩種代碼所獲取的結果不同：

1.　byte a = 1;
2.　a++;//++不修改數據類型
3.　a=(byte)(a+1);//a+1的結果為int，所以必須強制類型轉換才可以回到byte上

4.1.2　關系運算符

關系運算符用于比較兩個數值的大小，比較結果為boolean值。>=、<=、>、<可以直接比較兩個數值，==和!=不僅可以比較數值，還可以比較任意對象的內存地址。

示例程序如下：

【文件4.5】Operation4.java

1.　int a = 1;
2.　int b = 1;
3.　Integer c = new Integer(1);
4.　String str1 = "Jack";
5.　String str2 = new String("Jack");
6.　boolean b1 = a == b;
7.　boolean b2 = a == c;
8.　boolean b3 = str1 == str2;

第6行直接比較兩個數值的結果為true。在第7行，雖然c是對象類型，但是在JDK 1.5以后會自動將c拆成int類型，所以也是直接比較兩個值，結果為true。第8行為比較兩個對象類型的內存是否一樣，由于str2是一個新內存對象的聲明，因此第8行的結果為false。

4.1.3　邏輯運算符

&（與）和|（或）既可以進行邏輯運算，也可以進行位運算。當&（與）兩邊運算表達式的值都為true時，結果為true；兩邊只要有一方為false，則結果為false。|（或）兩邊表達式的值只要有一個為true則結果為true，只有兩邊都為false時結果才為false。值得注意的是，&和|兩邊的表達式無論如何都會參與運算。

請見以下表達式：

1.　boolean boo1 = true & false;// false
2.　boolean boo2 = true & true;// true;
3.　boolean boo3 = false | true;// true

兩邊都為運算表達式時，表達式兩邊都會參與運算:

     boolean boo1 = (1==2) & (1==1);// false

&&（短路與）、||（短路或）的兩邊只能是boolean表達式。使用&&時，如果&&左邊的表達式已經為false，則無論右邊為true還是false，結果都是false，此時右邊的表達式將不再參與運算，所以叫作短路與運算。同樣的，對于||（短路或），如果左邊已經是true，那么無論右邊是true還是false都將為true，此時右邊也不再參與運算，所以叫短路或。

在進行比較時，雖然使用&&和||可以省去不必要的運算，但是也會帶來一些問題，如下代碼將不會拋出異常。

【文件4.6】Operation5.java

1.　String str = null;
2.　boolean boo = false && str.length()==3;
3.　System.err.println(boo);

在上面的第2行中，str為null值，如果直接調用str.length()獲取長度，則會拋出一個NullPointerException異常，但是&&左邊已經是false，右邊不會參與運算，所以不會拋出異常。如果將&&修改為&，將會拋出NullPointerException異常，因為&兩邊都會參與運算，此時str的值為null：

1.　String str1 = null;
2.　boolean boo1 = false & str.length()==3;
3.　System.err.println(boo1);

使用^（異域運算符）時，兩個表達值式的值不一樣時結果才是true，即：

1.　boolean boo1 = false ^ true;// true
2.　boolean boo2 = false ^ false;// false

!（非運算符號）為取反操作，如!true的結果為false，!false的結果為true。

4.1.4　位運算符

位運算符包含的符號有&（與）、|（或）、~（按位取反）、>>（右位移）、<<（左位移）、>>>（無符號位移），是對二進制數據進行運算，即運算的對象為0和1。

&（與）運算符的兩邊都為1時結果為1，例如：

【文件4.7】Operation6.java

1.　// 聲明一個二進制的數15，使用0b聲明一個二進制的數
2.　int a = 0b00000000_00000000_00000000_00001111;
3.　// 聲明一個二進制的1
4.　int b = 0b00000000_00000000_00000000_00000001;
5.　// a&b則c的結果為1
6.　int c = a & b;

在上例中，c的結果為1，運算過程如圖4-1所示。

圖4-1

進行|（或）運算時，只要表達式的兩邊有一個為1，結果就是1。

【文件4.8】Operation7.java

1.　// 聲明一個二進制的數15，使用0b聲明一個二進制的數
2.　int a = 0b00000000_00000000_00000000_00001111;
3.　// 聲明一個二進制的1
4.　int b = 0b00000000_00000000_00000000_00000001;
5.　// a|b，則c的結果為15
6.　int c = a | b;

在上例中，c的結果為15，運算過程如圖4-2所示。

圖4-2

~是按位取反運算符號，若是1則轉換成0，若是0則轉換成1。

【文件4.9】Operation8.java

1.　// 聲明一個二進制的數15，使用0b聲明一個二進制的數
2.　int a = 0b00000000_00000000_00000000_00001111;
3.　int b = ~a;
4.　System.err.println(b);//-16
5.　//11111111111111111111111111110000
6.　System.err.println(Integer.toBinaryString(b));

在上例中，第4行的輸出為-16。a的首位是0，按位取反以后為1，對于一個二進制來說，首位為1時為負數，所以b的值為負數。

在第6行中，通過Integer包裝類型的靜態方法，將b轉成二進制的結果為11111111111111111111111111110000，正是a值按位取反以后的結果。

>>（右位移）和<<（左位移）運算是將二進制數據向右或左進行位移，移出去的數據將在前面或者后面補0。

1.　int a = 0b00000000_00000000_00000000_00001111;
2.　int b = a >> 2;//結果為3

上面的向右位移運算過程如圖4-3所示。

圖4-3

向右位移兩位以后，移出兩個1，前面補兩個0，所以最后的二進制結果為00000000_00000000_00000000_00000011，這個二進制數據的結果為2。

左位移運算同理，只是后面補0，不再贅述。

>>>為無符號位移運算符，對于>>右位移運算，如果為負數，則前面補1，即依然是負數。如>>右位移運算的示例：

【文件4.10】Operation9.java

1.　int a = 0b10000000_00000000_00000000_00000000;
2.　int b = a >> 2;
3.　String bin = "00000000000000000000000000000000" + Integer.toBinaryString(b);
4.　bin = bin.substring(bin.length() - 32);
5.　System.err.println(b + "," + bin);

在上面的代碼中，a變量的二進制形式是以1開始的，所以為負數，使用>>右移兩位，即后面去除兩個0，則是有符號位移，所以前面補1，結果為-536870912，11100000000000000000000000000000，即依然為負數。如果使用>>>無符號位移，即將第2行的代碼修改成“int b =a>>>2;”，結果為536870912，00100000000000000000000000000000即前面補0，結果為正數。對于無符號位移，無論是正數還是負數，前面都補0，有符號位移則會根據情況前面補0或補1。