Java運算子詳談

運算子

1.1算術運算子

基本四則運算子:

+  -  *  /  %

規則比較簡單，這基本和C/C++中的運算子沒有區別，值得注意的是除法：

1. int / int 結果還是int，如果需要小數，則需要double進行計算，

int a = 1; 
int b = 2; 
System.out.println(a / b); 
// 結果為 0

2. 0 不能作為除數，

System.out.println(1 / 0); 
//運行結果 會出現例外，編譯能通過，但運行不了
Exception in thread "main" java.lang.ArithmeticException: / by zero
       at Test.main(Test.java:3)

3. % 表示取余, 不僅僅可以對 int 求模, 也能對 double 來求模

System.out.println(11.5 % 2.0); 
// 運行結果
1.5

//負數也可以取模
System.out.println(10 % -3);
System.out.println(-10 % 3);
System.out.println(-10 % -3);
// 運行結果
 1
-1
-1

增量賦值運算子：

 +=  -=  *=  /=  %=

int a = 10; 
a += 1; // 等價于 a = a + 1 
System.out.println(a);

自增/自減運算子：

++  --

int a = 10; 
int b = ++a;  //先自增再使用
System.out.println(b); 
//運行結果：
11

int a = 10;
int c = a++;  //先使用再自增
System.out.println(c);
//運行結果：
10

特別注意：
int i = 10;
i = i++;
System.out.println(i);
//運行結果：
在java中i的結果是10，而在C/C++中是11

結論：

1. 如果不取自增運算的運算式的回傳值, 則前置自增和后置自增沒有區別，
2. 如果取運算式的回傳值, 則前置自增的回傳值是自增之后的值, 后置自增的回傳值是自增之前的值，

1.2關系運算子

關系運算子主要有六個：

==   ！=   <  >   <=   >= 

int a = 10; 
int b = 20; 
System.out.println(a == b); //false
System.out.println(a != b); //true
System.out.println(a < b); //true
System.out.println(a > b); //false
System.out.println(a <= b); //true
System.out.println(a >= b); //false

**注意：**關系運算子的運算式回傳值都是 boolean 型別，

1.3 邏輯運算子(重點)

邏輯運算子主要有三個:

&&  ||  ！

注意：
邏輯運算子的運算元(運算元往往是關系運算子的結果)和回傳值都是 boolean，

邏輯與 &&

規則: 兩個運算元都為 true, 結果為 true, 否則結果為 false，
格式：

運算式1 && 運算式2

int a = 10; 
int b = 20; 
int c = 30; 
System.out.println(a < b && b < c);//true
System.out.println(a > b && b < c);//false

要注意：如果運算式1的結果為false，則不需要再判斷運算式2，最終結果為false，

邏輯或 ||

規則: 兩個運算元都為 false, 結果為 false, 否則結果為true，
格式：

運算式1 || 運算式2

int a = 10; 
int b = 20; 
int c = 30; 
System.out.println(a < b || b < c);//true
System.out.println(a > b || b < c);//true
System.out.println(a > b || b > c);//false

邏輯非 !

規則: 運算元為 true, 結果為 false; 運算元為 false, 結果為 true(這是個單目運算子, 只有一個運算元)，！只能作用于布爾型別，

int a = 10; 
int b = 20; 
System.out.println(！a < b); //false

結論：

1. 對于 && , 如果左側運算式值為 false, 則運算式的整體的值一定是 false, 無需計算右側運算式，
2. 對于 ||, 如果左側運算式值為 true, 則運算式的整體的值一定是 true, 無需計算右側運算式，

& 和 | (不推薦使用)

& 和 | 如果運算元為 boolean 的時候, 也表示邏輯運算. 但是和 &&以及 || 相比，他們不支持短路求值，

System.out.println(10 > 20 & 10 / 0 == 0); // 程式拋出例外
System.out.println(10 < 20 | 10 / 0 == 0);// 程式拋出例外

1.4 位運算子

Java 中對資料的操作的最小單位不是位元組, 而是二進制位.
位運算子主要有四個:

&  |  ~  ^

位操作表示按二進制位運算，計算機中都是使用二進制來表示資料的(01構成的序列), 按位運算就是在按照二進制位的每一位依次進行計算，

按位與 &:

如果兩個二進制位都是1，則結果為1，否則結果為0 ，

int a = 10; 
int b = 20; 
System.out.println(a & b);
//運算結果 
0

進行按位運算, 需要先把 10 和 20 轉成二進制，分別為1010 和 10100，如圖所示：

按位或 |:

如果兩個二進制位都是 0, 則結果為 0, 否則結果為 1，

int a = 10; 
int b = 20; 
System.out.println(a | b);
//運算結果為 30

運算方式和按位于類似，如圖所示：

注意: 當 & 和 | 的運算元為整數(int, short, long, byte) 的時候, 表示按位運算, 當運算元為 boolean 的時候, 表示邏輯運算，

按位取反 ~:

如果該位為 0 則轉為 1, 如果該位為 1 則轉為 0，

int a = 10;
System.out.println(~a);

按位異或 ^:

如果兩個數字的二進制位相同，則結果為0，相異則結果為1，

int a = 10; 
int b = 20; 
System.out.println(a ^ b);
//運行結果 30

運算方式和按位于類似，如圖所示：

1.5移位運算(了解)

移位運算子有三個:

<<  >>  >>>

都是按照二進制位來運算，

左移 <<：

最左側位不要了，最右側補0，

int a = 10;
System.out.println(a<<1); //左移一位

如圖所示：

右移 >>:

最右側位不要了, 最左側補符號位(正數補0, 負數補1)

int a = 10;
System.out.println(a >> 1); //右移一位
//運行結果 5

int a = -1;
System.out.println(a >> 1);
//運行結果 -1

如圖所示:

無符號右移 >>>:(特別)

最右側位不要了, 最左側補 0(不管符號位)

int a = -1;
System.out.println(a >>> 1);
//運行結果 2147483645

如圖所示：

注意：

1. 左移 1 位, 相當于原數字 * 2，左移 N 位, 相當于原數字 * 2 的N次方，
2. 右移 1 位, 相當于原數字 / 2.，右移 N 位, 相當于原數字 / 2 的N次方，
3. 由于計算機計算移位效率高于計算乘除, 當某個代碼正好乘除 2 的N次方的時候可以用移位運算代替，
4. 移動負數位或者移位位數過大都沒有意義，

1.6條件運算子

條件運算子只有一個:

運算式1 ? 運算式2 : 運算式3;

當 運算式1的值為true時, 整個運算式的值為運算式2的值; 當運算式1的值為 false 時, 整個運算式的值為運算式3的值，也是 Java 中唯一的一個 三目運算子, 是條件判斷陳述句的簡化寫法，

// 求兩個整數的最大值
int a = 10; 
int b = 20; 
int max = a > b ? a : b;
//運行結果： 
20

1.7運算子的優先級

先看一段代碼：

System.out.println(1 + 2 * 3);

結果為 7, 說明先計算了 2*3 , 再計算 1+，
另外一個例子：

System.out.println(10 < 20 && 20 < 30);

此時明顯是先計算的 10 < 20 和 20 < 30, 再計算 &&. 否則 20 && 20 這樣的操作是語法上有誤的(&& 的運算元只能是boolean)，
結論：
運算子之間是有優先級的. 具體的規則我們不必記憶，在可能存在歧義的代碼上加上括號即可，

1.8小結

1. % 操作再 Java 中也能針對 double 來計算，
2. 需要區分清楚 前置自增 和 后置自增之間的區別，
3. 由于 Java 是強型別語言, 因此對于型別檢查較嚴格, 因此像 && 之類的運算運算元必須是 boolean，
4. 要區分清楚 & 和 | 什么時候是表示按位運算, 什么時候表示邏輯運算，
   整體來看, Java 的運算子的基本規則和C/C++語言基本一致，