運算子介紹

• 算術運算子
• 賦值運算子
  • 擴充套件運算子
• 關係運算符
• 邏輯運算子
• 位運算子
• 條件運算子
• 字串連線符

運算子分類

算術運算子

+、-、*、/、%（%指的是取餘數）:加減乘除取餘這幾個操作符屬於二元運算子。
二元運算子指的是需要兩個運算元才能完成運算的運算子。
其中的 % 是取模運算子，即求餘數

二元運算子的運算規則：

整數運算

1. 如果兩個運算元有一個為 Long 型別，則結果也為 long
2. 沒有 long 時，結果為 int 。即使運算元全為 short，byte，結果也是 int。

浮點運算

3. 如果兩個運算元有一個為 double，則結果為 double
4. 兩個運算元都為 float，則結果才為 float

// 測試算術運算子
public class testOperator01 {
    public static void main(String[] args) {
        byte a = 1;
        int b = 2;
        long b2 = 3;
        // 報錯，c 為 int 型別。因為無論short，byte，都預設是 int，所以不能放在 byte 中。沒有 long 時，結果為 int
        byte c =  a + b; // 報錯
        // c2 為 long 型別。因為當運算元中有一個為 long 時，結果也為 long 型別， long 型別不能放在 int 中
        int c2 = b2 + a; // 報錯

        // 表數範圍較大的時候，會自動轉換型別，不會報錯
        float f1 = 3.14F;
        // double 和 float 的表數範圍比 int、byte、long 要大，所以不會報錯。
        double d = b + b2;  // 正確
        float d1 = b + b2;  // 正確
        // 6.2 是 double 型別，所以結果 d2 也是 double 型別，其無法放進 float 中
        float d2 = f1 + 6.2; // 報錯
    }
}
 

取模運算

1. 運算元可以為浮點數，一般使用整數，結果為“餘數”
2. “餘數”符號和左邊運算元一樣。如7%2=1，-7%2=-1，7%-2==1

// 運算結果“餘數”的符號和左邊運算元一樣。
System.out.println(-9%4);   // 結果為 -1
System.out.println(9%-4);   // 結果為  1
System.out.println(9%4);    // 結果為  1
System.out.println(-9%-4);  // 結果為 -1

運算子：自增 ++、自減 --

算術運算子中 ++、-- 屬於一元運算子，該類運算子只需要一個運算元。

測試自增 ++、自減 -- 算術運算子

public class testOperator01 {
    public static void main(String[] args) {
        // 測試自增：++
        int a = 3;
        int b = a++;   // 先給 b 賦值，然後 a 再自增，主要看 ++ 放置的位置
        int c = ++a;   // a 先自增，再複製給 c ，主要看 ++ 放置的位置
        System.out.println("a="+a+"\nb="+b+"\nc="+c); // 測試結果為 a=4，b=3，c=5

        // 測試自減：--
        int a1 = 3;
        int b1 = a1--;   // 先給 b1 賦值，然後 a1 再自減，主要看 -- 放置的位置
        int c1 = --a1;   // a1 先自減，再複製給 c1 ，主要看 -- 放置的位置
        System.out.println("a1="+a1+"\nb1="+b1+"\nc1="+c1); // 測試結果為 a1=1，b1=3，c1=1
    }
}

賦值運算子

賦值運算子及其擴充套件運算子

含義如圖所示：

程式碼示例：賦值運算子及其擴充套件運算子

// 賦值運算子及其擴充套件運算子運算示例
public class testOperator01 {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        int c = 5;
        a += b;  //相當於 a = a + b
        System.out.println("a="+a+"\nb="+b); // 結果為 a = 7，b = 4
        b *= c;
        System.out.println("b="+b+"\nc="+c); // 結果為 b = 20，c = 5
    }
}

關係運算符

1. 關係運算符用於做比較運算
2. 關係運算符的結果為布林值：true / false

關係運算符

注意點

1. = 是賦值運算子，而真正判斷兩個運算元是否相等的運算子是 ==
2. == 、!= 是所有（基本和引用）資料型別都可以使用
3. > 、>= 、< 、<= 僅針對資料型別（byte/short/int/long，float/double 以及 char）

// 測試關係運算符
public class TestOperator02 {
    public static void main(String[] args) {
        // 測試基本關係運算符
        int c = 3;
        System.out.println(c==3); // true
        System.out.println(c!=3); // false
        System.out.println(c>=3); // true
        System.out.println(c>3);  // false

        // 比較 char 資料型別
        // char 
        char a = 'a';
        char b = 'b';
        // char 型別在做比較時，會轉化成 數字 進行計算
        System.out.println(a==b); // false
        System.out.println(a>=b); // false
        System.out.println(a<=b); // true
        // 輸出結果為字元 a，只有在比較時才會轉化成數字進行比較
        System.out.println(a);    // 輸出結果為字元 a
        // 可以通過強轉，將字元 轉為 數字
        System.out.println((int)a);  // 97
        System.out.println(0+a);     // 97
        System.out.println((int)b);  // 98
        System.out.println(0+b);     // 98
    }
}

邏輯運算子

邏輯運算子圖表

邏輯異或 ^ ：相同為 false，不同為 true

短路與、短路或

短路與 &&：只要有一個為 false，則直接返回 false
短路或 ||：只要有一個為 true，則直接返回 true

public class TestOperator03 {
    public static void main(String[] args) {
        boolean b1 = true;
        boolean b2 = false;
        System.out.println(b1&b2); // false
        System.out.println(b1|b2); // true
        System.out.println(b1^b2); // true
        System.out.println(!b2); // true

        // 測試短路與、短路或
        boolean b3 = 1>2 && 2<(3/1); // 短語與：第一個運算元為 false，則整個邏輯表示式值為 false
        boolean b4 = 1>2 || 2<(3/1); // 短路或：有一個為 true，則整個邏輯表示式值為 true
        System.out.println(b3);      // false
        System.out.println(b4);      // true
    }
}

注意點

1. 短路與 和 短路或 採用短路的方式，從左往右計算。
2. 如果通過運算子左邊的運算元能夠確定該邏輯表示式的值，則不會繼續計算運算子右邊的運算元，直接輸出對應值，以此提高效率。

位運算子

位運算子指的是進行二進位制位的運算

常用的位運算子

運算元演示

位運算程式碼演示

public class TestOperator04 {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        System.out.println(a&b); // 0
        System.out.println(a|b); // 7
        System.out.println(a^b); // 7
        System.out.println(~a);  // -4

        // 移位運算
        int c = 3<<2;  // 結果為12 。c = 3 * 2 * 2
        int d = 3<<4;  // 結果為48 。d = 3 * 4 * 4
        int e = 12>>2; // 結果為3 。e = 12 / (2*2)
        int f = 3>>4;  // 結果為0 。f = 3 / (2*2)
        System.out.println(c); // 12
        System.out.println(d); // 48
        System.out.println(e); // 3
        System.out.println(f); // 0
        System.out.println(3/4);   //結果為0，取整運算。有 0 個 4，所以結果為 0
        System.out.println(3%4);   //結果為3，取餘運算。餘數為 3，所以結果為 3
    }
}

注意點：

1. 按位或：有 1 為真，全 0 為假
2. 按位異或：不同為真，相同為假
3. ~ 取反運算是單目運算，用來求一個位串資訊按位的反，只能對一個數進行操作（對轉換後的二進位制數進行取反：0 <轉> 1）

字串連線符

注意點

1. "+" 運算子兩側的運算元中只要有一個是字串（String）型別，系統會自動將另一個運算元轉換為字串進行連線。
2. "+" 運算子如果兩側的運算元全為數字時，則進行數字之間的計算。
3. "+" 運算子進行運算時，如果字元型資料遇到數字，會將自身轉換為相應的數字進行“加”運算

public class TestOperator05 {
    public static void main(String[] args) {
        String a = "3";
        int b = 4;
        int c = 5;
        char d = 'a';  // 字元型資料
        System.out.println(a+b+c);// 結果為 345，先 a + b 進行字串拼接，隨後再 + c 進行字串拼接
        System.out.println(b+c+a);// 結果為 93，先是 b + c 數字運算，再與 a 進行字串拼接
        System.out.println(d);    // 結果為 a，
        System.out.println(b+c+d);// 結果為 106。字元型資料 和 數字進行 “+” 運算時，字元型資料會變成對應的數字進行運算
    }
}

條件運算子

語法格式

// x 為 boolean 型別表示式，先計算 x 的值，若為 true，則整個運算子的結果為表示式 y 的值，反之運算子結果為表示式 z 的值

x ? y : z

程式碼示例

// 測試條件運算子
public class TestOperator06 {
    public static void main(String[] args) {
        int score = 80;
        int x = -100;
        String type = score < 60?"不及格":"及格";
        System.out.println(type); // 結果為 及格
        // 測試條件運算子套用
        System.out.println(x > 0?1:(x == 0?0:-1));  // 結果為 -1
    }
}

運算子優先順序

注意點

1. 常用運算子優先順序：邏輯非 > 邏輯與 > 邏輯或
2. a || b && c 的運算結果為： a || (b && c) 而不是 (a || b)&& c 。結果由運算子優先順序產生。
3. 表示式中優先使用小括號來組織區分。

運算子知識內容自此結束。