Java基礎之運算符

2022 年 10 月 1 日
筆記
Java之運算符, Java合集

Java基礎之運算符

Java基礎之運算符

1.1 運算符介紹

1.1.1 運算符介紹

運算符是一種特殊的符號，用以表示數據的運算、賦值和比較等，運算符可分為：

1）算術運算符

2）賦值運算符

3）關係運算符 [比較運算符]

4）邏輯運算符

5）位運算符 [需要二進位]

6）三元運算符

1.2 算術運算符

1.2.1 介紹

算術運算符是對數值類型的變數進行運算的，在Java程式中使用非常多

1.2.2 算術運算符一覽表

1.2.3 程式碼演示

public class ArithmeticOperator {
    /**
     * 演示算數運算符的使用
     */
    public static void main(String[] args) {
        System.out.println(10 / 4); //2   兩個數都是int類型，結果為int類型
        System.out.println(10.0 / 4); //2.5  有一個為double類型，結果為double類型

        double d = 10 / 4; //10 / 4 為int類型，會自動轉換為double類型
        System.out.println(d); //2.0

        // % 取余（取模）
        //在Java中 % 的本質是：a % b = a - a / b * b
        //-10 % 3 => -10 - (-10) / 3 * 3 = -10 + 9 = -1
        //10 % -3 => 10 - 10 / (-3) * (-3) = 10 - 9 = 1
        //-10 % -3 => -10 - (-10) / (-3) * (-3) = -10 + 9 = -1
        System.out.println(10 % 3); // 1
        System.out.println(-10 % 3); // -1
        System.out.println(10 % -3); // 1
        System.out.println(-10 % -3); // -1

        // ++的使用
        /*
            作為語句獨立使用：
            前++ 和 後++ 獨立使用時都等價於 i = i + 1;
         */
        int i = 10;
        i++; //自增  等價於 i = i + 1; => i = 11;
        ++i; //自增  等價於 i = i + 1; => i = 12;
        System.out.println("i=" + i); //12
        /*
            作為表達式使用：
            前++: ++i 先自增後賦值
            後++: i++ 先賦值後自增
         */
        int j = 8;
        int k = ++ j; //等價於 j = j + 1; k = j;
        int n = j ++; //等價於 n = j; j = j + 1;
        System.out.println("k=" + k + "n=" + n + "j=" + j); // k=9  n=9  j=10
    }
}

1.2.4 細節說明

對於除號”/”，它的整數除和小數除是有區別的：整數之間做除法時，只保留整數部分而捨棄小數部分。例如： int x = 10 / 3; 結果為3。
當對一個數取余（取模），可以等價a % b = a - a / b * b ,根據這個公式，我們可以看到取余的一個本質運算。
當自增當做一個獨立語言使用時，不管是++i 還是 i++ 都是一樣的，等價於 i = i + 1。
當自增當做一個表達式使用時，前++: ++i 先自增後賦值；後++: i++ 先賦值後自增

1.2.5 面試題

1）面試題一

int i = 1;

i = i++;

System.out.println(i);

結果為多少？為什麼？

i = i++; 後++ 先賦值，後自增。這一過程中使用了臨時變數來存放i的值

（1）int temp = i; // temp=1

（2）i = i + 1; // i=2

（3）i = temp; // i=1

所以最後結果為：i = 1

2）面試題二

int i = 1;

i = ++i;

System.out.println(i);

結果為多少？為什麼？

i = ++i; 前++ 先自增，後賦值。這一過程中使用了臨時變數來存放i的值

（1）i = i + 1; // i=2

（2）int temp = i; // temp=2

（3）i = temp; // i=2

所以最後結果為：i = 2

1.2.6 小練習

1）看看輸出是什麼?

  int i1 = 10; 
  int i2 = 20; 
  int i = i1++; 
  System.out.print("i="+i); //10 
  System.out.println("i2="+i2); //20 
  i = --i2; 
  System.out.print("i="+i); //19 
  System.out.println("i2="+i2); //19

步驟如下:

i1 = 10;

i2 = 20;

i = i1++; // 先賦值，後自增 i=10，i1=11，i2=20

i = –i2; // 先自減，後賦值 i2=19，i=19

2）假如還有 59 天放假，問：合 xx 個星期零 xx 天

public class ArithmeticOperatorExercise {
    public static void main(String[] args) {
        //假如還有 59 天放假，問：合 xx 個星期零 xx 天
        /*
             1）需求：
               假如還有 59 天放假，問：合 xx 個星期零 xx 天
             2）思路分析：
               使用int型變數來存放天數
               一星期有7天
               天數除以7 可得星期數
               天數對7取余 可得零幾天
             3）走程式碼：
         */
        int days = 59;
        int weeks = days / 7;
        int leftDays = days % 7;
        System.out.println(days + "天合" + weeks + "個星期零" + leftDays + "天");
    }
}

3）定義一個變數保存華氏溫度，華氏溫度轉換攝氏溫度的公式為：

5/9*(華氏溫度-100),請求出華氏溫度對應的攝氏溫度。 [234.5]

public class ArithmeticOperatorExercise {
    public static void main(String[] args) {     
        /*
             1）需求：
               定義一個變數保存華氏溫度，請求出華氏溫度對應的攝氏溫度。
             2）思路分析：
               定義一個double變數fahrenheit保存華氏溫度
               根據公式計算對應的攝氏溫度
               定義一個double變數Celsius保存攝氏溫度
             3）走程式碼：
         */
        double fahrenheit = 1234.6;
        double Celsius = 5.0 / 9 * (fahrenheit - 100);
        System.out.println("華氏溫度" + fahrenheit + " 對應的攝氏溫度="+ Celsius);
    }
}

1.3 關係運算符（比較運算符）

1.3.1 介紹

1）關係運算符的結果都是boolean類型，要麼是true，要麼是false。

2）關係表達式經常用在if結構的條件或循環結構的條件中。

1.3.2 關係運算符一覽表

1.3.3 案例演示

public class RelationalOperator { 
    //編寫一個 main 方法 
    public static void main(String[] args) { 
        int a = 9; // 開發中，不可以使用 a, b 
        nt b = 8; 
        System.out.println(a > b); //T 
        System.out.println(a >= b); //T 
        System.out.println(a <= b); //F 
        System.out.println(a < b);//F 第 63頁
        System.out.println(a == b); //F 
        System.out.println(a != b); //T 
        boolean flag = a > b; //T 
        System.out.println("flag=" + flag); 
    } 
}

在開發中不可以使用a、b這種簡單的字元來命名變數

1.3.4 細節說明

1）關係運算符的結果都是boolean類型，要麼是true，要麼是false。

2）關係運算符組成的表達式，我們稱為關係表達式。

3）比較運算符”= =”不能誤寫成”=”。

1.4 邏輯運算符

1.4.1 介紹

用於連接多個條件（多個關係表達式），最終的結果也是一個boolean值。。

1.4.2 邏輯運算符一覽表

1）短路與 &&，短路或 ||，取反！

2）邏輯與 &，邏輯或 |，邏輯異或 ^

3)運算規則說明：

a & b：& 叫邏輯與。當a和b同時為true，則結果為true，否則為false
a && b：&& 叫短路與。當a和b同時為true，則結果為true，否則為false
a | b：| 叫邏輯或。當a和b有一個為true，則結果為true，否則為false
a || b：|| 叫短路或。當a和b有一個為true，則結果為true，否則為false
!a：叫取反。當a為true，則結果為false；當a為false，則結果為true
a ^ b：叫邏輯異或。當a和b不同時，則結果為true，否則為false

1.4.3 && 和 & 基本規則

名稱語法特點

短路與&& 條件1 && 條件2 當兩個同時為true，則結果為true，否則為false。如果條件1為false，則不判斷條件2，結果為false

邏輯與& 條件1 & 條件2 當兩個同時為true，則結果為true，否則為false.如果條件1為false，繼續判斷條件2，結果為false

1.4.4 && 和 & 案例演示

public class LogicOperator01 {
    public static void main(String[] args) {
        // &&短路與 和 &邏輯與 演示
        /*
              && 規則: 兩個條件都為true，結果為 true,否則為 false
              & 規則: 兩個條件都為true，結果為 true,否則為 false
         */
        // &&短路與
        int age =50;
        if(age > 20 && age < 90){
            System.out.println("0k100");
        }
        // &邏輯與
        if(age > 20 & age < 90) {
            System.out.println("ok200");
        }
        //區別
        int a = 4;
        int b = 9;
        //對於&&短路與而言，如果第一個條件為 false ,後面的條件不再判斷
        //對於&邏輯與而言，如果第一個條件為 false ,後面的條件仍然會判斷
        if(a < 1 & ++b < 50) {
            System.out.println("ok300");
        }
        System.out.println("a=" + a + " b=" + b);// a=4  b=10
    }
}

1.4.5 && 和 & 使用區別

&&短路與：如果第一個條件為 false，則第二個條件不會判斷，最終結果為 false，效率高
& 邏輯與：不管第一個條件是否為 false，第二個條件都要判斷，效率低
開發中，我們使用的基本是使用短路與&&, 效率高

1.4.6 || 和 | 基本規則

名稱語法特點

短路或|| 條件1 && 條件2 當兩個中有一個為true，則結果為true，否則為false。如果條件1為true，則不判斷條件2，結果為true

邏輯或| 條件1 & 條件2 當兩個中有一個為true，則結果為true，否則為false.如果條件1為true，繼續判斷條件2，結果為true

1.4.7 || 和 | 案例演示

public class LogicOperator02 {
    public static void main(String[] args) {
        // ||短路或 和 |邏輯或 演示
        /*
             ||短路或: 兩個條件中只要有一個成立，結果為 true,否則為 false
             |邏輯或: 兩個條件中只要有一個成立，結果為 true,否則為 false
         */
        int age = 50;
        if(age > 20 || age < 30) {
            System.out.println("ok100");
        }
        //&邏輯與使用
        if(age > 20 | age < 30) {
            System.out.println("ok200");
        }
        //區別
        int a = 4;
        int b = 9;
        //對於||短路或而言，如果第一個條件為 true ,後面的條件不再判斷
        //對於|邏輯或而言，如果第一個條件為 true ,後面的條件仍然會判斷
        if( a > 1 || ++b > 4) {
            // 可以換成 | 測試
            System.out.println("ok300");
        }
        System.out.println("a=" + a + " b=" + b); //4 9

    }
}

1.4.8 || 和 | 使用區別

||短路或：如果第一個條件為 true，則第二個條件不會判斷，最終結果為 true，效率高
| 邏輯或：不管第一個條件是否為 true，第二個條件都要判斷，效率低
開發中，我們基本使用 ||

1.4.8 ! 取反基本規則

名稱語法特點

! 非（取反） ! 條件如果條件本身成立，結果為 false，否則為 true

1.4.9 ! 案例演示

public class InverseOperator {
    public static void main(String[] args) {
        // ! 操作是取反  T->F  F->T
        System.out.println(60 > 20); //T
        System.out.println(!(60 > 20)); //F

        // a^b:邏輯異或，當a和b不同時，則結果為true,否則為false
        boolean b = (10 > 1) ^ ( 3 > 5);
        System.out.println("b=" + b); //T
    }
}

1.4.10 ^ 基本規則

a^b: 叫邏輯異或，當 a 和 b 不同時，則結果為 true, 否則為 false

^邏輯異或，System.out.println( (4 < 1) ^ (6 > 3) );

1.4.11 練習題寫出輸出結果

        int x = 5;
        int y = 5;
        if(x++ == 6 & ++y == 6){ //①
            x = 11;  //②
        }
        System.out.println("x=" + x + "y=" + y);// x=6,y=6

講解：

在程式執行到①的時候，x++是後++，x先與6進行比較，結果為false,x加1之後x=6。

邏輯與第一個為false還要繼續判斷第二個條件。++y是先++，y先加1之後y=6,y與6進行判斷，結果為true。

false & true 結果為false,不執行if語句裡面的內容。

        int x = 5;
        int y = 5;
        if(x++ == 6 && ++y == 6){ //①
            x = 11; //②
        }
        System.out.println("x=" + x + "y=" + y);// x=6,y=5

講解：

在程式執行到①的時候，x++是後++，x先與6進行比較，結果為false,x加1之後x=6。

短路與第一個條件為false,不用判斷第二個條件，y沒有進行自加操作y=5。

        int x = 5;
        int y = 5;
        if(x++ == 5 | ++y == 5){ //①
            x = 11; //②
        }
        System.out.println("x=" + x + "y=" + y);// x=11,y=6

講解：

在程式執行到①的時候，x++是後++，x先與5進行比較，結果為true,x加1之後x=6。

邏輯或第一個為true還要繼續判斷第二個條件。++y是先++，y先加1之後y=6,y與5進行判斷，結果為false。

true | false 結果為true,執行if語句裡面的內容②，x=11。

        int x = 5;
        int y = 5;
        if(x++ == 5 || ++y == 5){ //①
            x = 11; //②
        }
        System.out.println("x=" + x + "y=" + y);// x=11,y=5

講解：

在程式執行到①的時候，x++是後++，x先與5進行比較，結果為true,x加1之後x=6。

短路或第一個為true不需要繼續判斷第二個條件。

執行if語句裡面的內容②，x=11。y沒有進行自加操作y=5。

        boolean x = true;
        boolean y = false;
        short z = 46;
        if((z++ == 46) && (y = true)) z++;  //①
        if((x = false) || (++z == 49)) z++;  //②
        System.out.println("z=" + z);  //z=50

講解：

在程式執行到①的時候，z++是後++，z先與46進行比較，結果為true，z加1之後z=47，判斷條件二，y被賦值為true。執行z++操作,z=48.

在程式執行到②的時候，x=false為false,繼續判斷第二個條件,++z是先++，z加1之後z=49。然後再執行z++操作，z=50.

1.5 賦值運算符

1.5.1介紹

賦值運算符就是將某個運算後的值，賦給指定的變數

1.5.2 賦值運算符的分類

基本賦值運算符 =：int a = 10;
複合賦值運算符

+=，-=，*=，/=，%= 等

舉例說明：

a += b; <==> a = a + b;

a -= b; <==> a = a – b;

1.5.3 賦值運算符的特點

1）運算順序從右往左 int num = a + b + c;

2）賦值運算符的左邊只能是變數，右邊可以是變數、表達式、常量

3）複合賦值運算符等價於下面的效果

a += 3 等價於 a = a + 3;

4）複合賦值運算符會進行類型轉換

  byte b = 3;
  b += 2; // 等價於 b = (byte)(b + 2);  如果直接寫成b=b+1,編譯會報錯
  b++; // b = (byte)(b + 1);

1.6 三元運算符

1.6.1 基本語法

條件表達式 ? 表達式1 : 表達式2;

運算規則：

1）如果條件表達式為true,運算後的結果是表達式1；

2）如果條件表達式為false,運算後的結果是表達式2；

1.6.2 使用細節

表達式 1 和表達式 2 要為可以賦給接收變數的類型(或可以自動轉換)
三元運算符可以轉成 if–else 語句

int res = a > b ? a++ : –b;

可以轉換成：

if(a > b) res = a++;

else res = –b;

public class TernaryOperator { 
    public static void main(String[] args) { 
        //表達式 1 和表達式 2 要為可以賦給接收變數的類型 //(或可以自動轉換/或者強制轉換) 
        int a = 3; 
        int b = 8; 
        int c = a > b ? (int)1.1 : (int)3.4;//可以 
        double d = a > b ? a : b + 3;//可以，滿足 int -> double
    } 
}

1.7 運算符的優先順序

可以記住口訣：後單四移關，等位邏三賦

單目運算符，四則運算符，移位運算符，關係運算符，等值運算符，位運算符，邏輯運算符，三目運算符，賦值運算符

Tags: Java之運算符 Java合集