07、Java 中的運算符

LittleTomato 2021-08-15 04:48:17 阅读数:916

本文一共[544]字,预计阅读时长:1分钟~
java

1、算術運算符

算術運算符 名稱 舉例
+ 加法 10 + 11 = 21
- 加法(數值取反) 15 - 10 = 5 或者 double d = 4.5; c = -b
* 乘法 10 * 10 = 100
/ 除法 100 / 10 = 10
% 求餘數 15 % 4 = 3
++ 自增1 int index = 5; index++;
-- 自减1 int index = 5; index--;
public static void main(String[] args) {
int numOne = 10, numTwo = 15;
System.out.println(numOne + numTwo); // 25
System.out.println(numOne - numTwo); // -5
System.out.println(-(numOne - numTwo)); // 5
System.out.println(numOne * numTwo); // 150
System.out.println(numTwo / numOne); // 1
System.out.println(numTwo % numOne); // 10
}

注意:當加號 + 出現在字符串之間,那麼它充當的是字符串連接符,而不是加法運算中的加號 +

什麼時候求和?什麼時候進行字符串的拼接操作呢?

  • + 運算符兩邊都是數字類型的時候,求和。
  • + 運算符兩邊的“任意一邊”是字符串類型的時候,那麼這個 + 會進行字符串拼接操作。
public static void main(String[] args) {
System.out.println(100 + 100); // 加法運算 200
// 當一個錶達式有多個加號的時候,遵循自左向右的順序依次執行。(除非額外添加了小括號,小括號的優先級高)
// 加號進行字符串拼接操作 String:201011
System.out.println("String:" + 2010 + 11);
// 加號進行字符串拼接操作 String:2021
System.out.println("String:" + (2010 + 11));
// 加號進行字符串拼接操作 2021String
System.out.println(2010 + 11 + "String");
// String 字符串型變量
String str = "NUMBER" + "_NUMBER";
System.out.println(str); // 加號進行字符串拼接操作 NUMBER_NUMBER
}

++/-- 可以出現在變量前也可以出現在變量後,在 ++/-- 執行結束之後,變量一定會自加(自减)1。

++/-- 出現在變量前和變量後的區別。

  • ++/-- 出現在變量後,會先做賦值運算,再自加(自减)1。
  • ++/-- 出現在變量前,會先進行自加(自减)1運算,然後再賦值。
public static void main(String[] args) {
int i = 10;
int k = i++;
System.out.println(k); // 10
System.out.println(k); // 11
int x = 100;
int y = ++x;
System.out.println(x); // 101
System.out.println(y); // 101
int a = 5;
int b = a--;
System.out.println(a); // 4
System.out.println(b); // 5
int c = 50;
int d = --c;
System.out.println(c); // 49
System.out.println(d); // 49
}

2、關系運算符

運算符 含義 舉例
> 大於運算符 2 > 3 返回 false
>= 大於或等於 4 >= 3 返回 true
< 小於 2 < 3 返回 true
<= 小於或等於 2 <= 1 返回 false
== 等於 2 == 3 返回 false
!= 不等於 2 != 3 返回 true

所有的關系型運算符的結果都是布爾類型,不是true就是false,不可能存在其它值。

Java語言中,= 錶示賦值運算符, == 關系運算符,判斷是否相等。

運算符存在兩個符號的話,兩個符號之間不能存在空格。

public static void main(String[] args) {
int a = 10;
int b = 10;
System.out.println(a > b); // false
System.out.println(a >= b); // true
System.out.println(a < b); // false
System.out.println(a <= b); // true
System.out.println(a == b); // true
System.out.println(a != b); // false
}

3、邏輯運算符

運算符 用法 含義
&& a && b 短路與
|| a || b 短路或
! !a 邏輯非(取反)
| a | b 邏輯或(或者)
& a & b 邏輯與(並且)

邏輯運算符兩邊要求都是布爾類型,並且最終的運算結果也是布爾類型。

對於邏輯與 & 運算符來說,只要有一邊是 false ,結果就是 false ,只有兩邊同時為 true ,結果才是 true

public static void main(String[] args) {
int a = 10;
int b = 10;
System.out.println(a > b & a == b); // false
System.out.println(a >= b & a == b); // true
System.out.println(a > b & a < b); // false
}

對於邏輯或 | 來說,只要有一邊是 true ,結果就是 true ,只有兩邊同時為 false 時結果才是 false

public static void main(String[] args) {
int a = 10;
int b = 10;
System.out.println(a > b | a == b); // true
System.out.println(a >= b | a == b); // true
System.out.println(a > b | a < b); // false
}

邏輯非 ! 就是對現有的結果取反。

public static void main(String[] args) {
int a = 10;
int b = 10;
System.out.println(!(a == b)); // false
System.out.println(!(a > b)); // true
}

短路與 && 和邏輯 && 有什麼區別?

  • 結果無區別,但是短路與或發生短路現象。
System.out.println(true & true); // true
System.out.println(true && true); // true

什麼是短路現象,什麼時候發生“短路”?

a > b && a < b 左邊錶達式執行了,但是右邊錶達式不執行,這種情况通常發生在左邊為 false 的時候。

int x = 10;
int y = 11;
System.out.println(x > y & x < y++);
System.out.println(y); // 12
int a = 10;
int b = 11;
System.out.println(a > b && a < b);
System.out.println(b); // 11

短路或 || 只要有一邊是 true ,結果就是 true ,左邊錶達式為 true 的時候,會發生短路。

注意:短路與和短路或能够采用更加優化的計算方式,在實際開發中建議優先考慮短路與和短路或

4、賦值運算符

賦值運算符包括 基本賦值運算符擴展賦值運算符

  • 基本賦值運算符:=
  • 擴展賦值運算符:+= -= *= /= %=
public static void main(String[] args) {
int x = 10;
x += 10; // 等同於 x = x + 10;
Syste,.out.println(x); // 20
x -= 10; // 等同於 x = x - 10;
System.out.println(x); // 10
x *= 10;
System.out.println(x); // 100
x /= 10;
System.out.println(x); // 10
x %= 3;
System.out.println(x); // 1
}

x = x + 10x += 10 的區別:使用擴展運算符的時候,永遠都不會改變運算結果類型。

public static void main(String[] args) {
byte x = 100;
System.out.println(b); // x
// 錯誤: 不兼容的類型: 從int轉換到byte可能會有損失
// x = x + 1;
x += 1; // x = (byte) (x + 1)
System.out.println(x); // 101
}

5、條件運算符(三目運算符)

語法格式:布爾錶達式 ? 錶達式1 : 錶達式2

  • 布爾錶達式為 true 時,錶達式1的執行結果作為整個錶達式的結果
  • 布爾錶達式為 false 時,錶達式2的執行結果作為整個錶達式的結果
public static void main(String[] args) {
int i = 100;
char sex = i == 100 ? '男' : '女';
System.out.println(sex); // 男
char c = i < 100 ? '男' : '女';
System.out.println(c); // 女
}

6、比特運算符

關於二進制、原碼、反碼、補碼和字符編碼相關知識

<< (左比特移運算符) 空比特補0,被移除的高比特丟弃
>> (右比特移運算符) 被移除的二進制最高比特是0,右移後,空缺補零,最高比特是1,最高比特補1。
& (按比特與運算符(AND) 任何二進制比特和0進行&運算,結果是0;和1進行&運算結果是原值。
| (按比特或運算符(OR) 任何二進制比特和0進行 | 運算,結果是原值;和1進行|運算結果是1
^ (按比特异或運算符(XOP)) 任何相同二進制比特進行 ^ 運算,結果是0;不相同二進制比特^運算結果是1
~ (按比特取反運算符(NOT)) 只對一個操作數進行運算,將操作數二進制中的 1 改為 0,0 改為 1

6.1、& 按比特與運算符(AND)

  • 任何二進制比特和0進行&運算,結果是0;和1進行&運算結果是原值。
/*
00000000 10010110 --> 150
&
00000000 00000011 --> 3
----------------------------------
00000000 00000010 ---> 2
*/
public static void main(String[] args) {
int x = 150, y = 3;
System.out.println(x & y); // 2
}

6.2、| 按比特或運算符(OR)

  • 任何二進制比特和0進行 | 運算,結果是原值;和1進行|運算結果是1
/*
00000000 10010110 ---> 150
|
00000000 00000011 ---> 3
----------------------------------------
00000000 10010111 ---> 151
*/
public static void main(String[] args) {
int x = 150, y = 2;
System.out.println(x | y); // 151
}

6.3、^ 按比特异或運算符(XOP)

  • 任何相同二進制比特進行 ^ 運算,結果是0;不相同二進制比特^運算結果是1
/*
00000000 10010110 ---> 150
^
00000000 00000011 ---> 3
--------------------------------------
00000000 10010101 ---> 149
*/
public static void main(String[] agrs) {
int x = 150, y = 2;
System.out.println(x | y); // 149
}

6.4、~ 按比特取反運算符(NOT)

  • 只對一個操作數進行運算,將操作數二進制中的 1 改為 0,0 改為 1
/*
00000000 00000000 00000000 000000011 ---> 3
--------------------------------------
11111111 11111111 11111111 111111100 ---> 6377292
*/
public static void main(String[] agrs) {
System.out.printf("%d \n", ~3); // -4
}

編譯程序,發現輸出的結果是 -4,而不是6377292,這是因為取反之後的結果是十六進制數,而在上面的程序中使用 %d 將輸出轉換為了十進制數。

public static void main(String[] agrs) {
System.out.printf("%x \n", ~10);
}

可以看到輸出結果為 fffffffc,將它轉換為二進制是 11111111 11111111 11111111 11111100。這個二進制數的最高比特為 1,錶示這個數為負數。除最高比特外,按比特取反再加 1,即得到二進制原碼 10000000 00000000 00000000 00000100,用十進制數錶示即為 -4。

6.4、<< 左比特移運算符

  • 按二進制形式把所有的數字向左移動對應的比特數,高比特移出(舍弃),低比特的空比特補零

image-20210814002034540

public static void main(String[] args) {
System.out.ptintln(1 << 1);
// 0000 0000 0000 0001
// 0000 0000 0000 0010
// 左移結果為2
}

6.5、>> 右比特移運算符

  • 將一個數的各二進制比特全部右移若幹比特,正數左補0,負數左補1,右邊丟弃。image-20210814002739082
public static void main(String[] args) {
System.out.println(3 >> 1);
// 0000 0000 0000 0011
// 0000 0000 0000 0001
// 3右移一比特結果為:1
System.out.println(-3 >> 1);
// 原碼:1000 0011
// 反碼:1111 1100
// 補碼:1111 1101
// 右移1:1111 1110
// 反碼:1111 1101
// 原碼:1000 0010
// 右移一比特結果為:-2
}


原創博主:Little Tomcat
博主原文鏈接:https://mp.weixin.qq.com/s/6zkhksxoD7c0zTUukbU6eA

版权声明:本文为[LittleTomato]所创,转载请带上原文链接,感谢。 https://gsmany.com/2021/08/20210815044807598n.html