2020-11-19 21:31:42  閱讀：6  來源： 互聯(lián)網(wǎng)

運算符概述

運算符是指對操作數(shù)的運算方式。組成表達式的 Java 操作符有很多種（什么是操作數(shù)和操作符，例如 1+2，其中 1 和 2 都是操作數(shù)，+是操作符，操作符和操作數(shù)聯(lián)合起來構成表達式）。 運算符按照其要求的操作數(shù)數(shù)目來分，可以有單目運算符（1 個操作數(shù)）、雙目運算符（2 個 操作數(shù)）和三目運算符（3 個操作數(shù)）。運算符按其功能來分有：

• 算術運算符

• 賦值運算符

• 比較運算符（關系運算符）

• 邏輯運算符

• 位運算符

• 三元運算符

運算符是存在優(yōu)先級的，那么如果不確定它們的優(yōu)先級怎么辦，其實很簡單，直接加小括 號就可以了，添加有小括號優(yōu)先級一定是高的，所以優(yōu)先級不需要死記硬背，不確定就加小括 號，例如：1 + 2 * 3，想確保先求和，你就需要這樣寫：(1+2)*3。

算術運算符

算術運算符包括：+（兩個數(shù)字求和）、-（兩個數(shù)字相減）、*（兩個數(shù)字乘積）、/（兩 個數(shù)字相除）、%（兩個數(shù)字取?；蛘咔笥啵?、++（單目運算符，對數(shù)字自加 1）、--（單目運算符，對數(shù)字自減 1）。我們一一來學習：

注意事項：

• /和%的區(qū)別：兩個數(shù)據(jù)做除法，/取結果的商，%取結果的余數(shù)。 整數(shù)操作只能得到整數(shù)，要想得到小數(shù)，必須有浮點數(shù)參與運算。

• 如果對負數(shù)取模，可以把模數(shù)負號忽略不記，如： 5%-2=1 。 但被模數(shù)是 負數(shù)則不可忽略。此外，取模運算的結果不一定總是整數(shù)

代碼示例

/*
除法公式：
被除數(shù) / 除數(shù) = 商 ... 余數(shù)
對于一個整數(shù)的表達式來說，除法用的是整除，整數(shù)除以整數(shù)，結果仍然是整數(shù)。只看商，不看余數(shù)。
只有對于整數(shù)的除法來說，取模運算符才有余數(shù)的意義。
注意事項：
    1. 一旦運算當中有不同類型的數(shù)據(jù)，那么結果將會是數(shù)據(jù)類型范圍大的那種。
*/public class Demo04Operator {
    public static void main(String[] args) {
        // 兩個常量之間可以進行數(shù)學運算
        System.out.println(20 + 30);
        
        // 兩個變量之間也可以進行數(shù)學運算
        int a = 20;
        int b = 30;
        System.out.println(a - b); // -10
        
        // 變量和常量之間可以混合使用
        System.out.println(a * 10); // 200
        
        int x = 10;
        int y = 3;
        
        int result1 = x / y;
        System.out.println(result1); // 3
        
        int result2 = x % y;
        System.out.println(result2); // 余數(shù)，模，1
        
        // int + double --> double + double --> double
        double result3 = x + 2.5;
        System.out.println(result3); // 12.5
    }}

字符的“+”操作

拿字符在計算機底層對應的數(shù)值來進行計算的

算術表達式中包含多個基本數(shù)據(jù)類型的值的時候，整個算術表達式的類型會自動進行提升。 提升規(guī)則：

• byte類型，short類型和char類型將被提升到int類型

• 整個表達式的類型自動提升到表達式中最高等級操作數(shù)同樣的類型 ，等級順序如下圖所示：

代碼示例

public class VariableTest1 {
    public static void main(String[] args) {
        //定義兩個變量
        int i = 10;
        char c = 'A'; //'A'的值是65
        c = 'a'; //'a'的值是97
        System.out.println(i + c);//107
        
        c = '0'; //'0'的值是48
        //char ch = i + c;
        //char類型會被自動提升為int類型
        int j = i + c;
        System.out.println(j);//58
    }}

字符串的“+”操作

在”+”操作中，如果出現(xiàn)了字符串，就是連接運算符，否則就是算術運算。當連續(xù)進行“+”操作時，從左到右逐個執(zhí)行。

/*
四則運算當中的加號“+”有常見的三種用法：
1. 對于數(shù)值來說，那就是加法。
2. 對于字符char類型來說，在計算之前，char會被提升成為int，然后再計算。
char類型字符，和int類型數(shù)字，之間的對照關系表：ASCII、Unicode
3. 對于字符串String（首字母大寫，并不是關鍵字）來說，加號代表字符串連接操作。
任何數(shù)據(jù)類型和字符串進行連接的時候，結果都會變成字符串
*/public class Demo {
    public static void main(String[] args) {
        // 字符串類型的變量基本使用
        // 數(shù)據(jù)類型 變量名稱 = 數(shù)據(jù)值;
        String str1 = "Hello";
        System.out.println(str1); // Hello
 
        System.out.println("Hello" + "World"); // HelloWorld
 
        String str2 = "Java";
        // String + int --> String
        System.out.println(str2 + 20); // Java20
 
        // 優(yōu)先級問題
        // String + int + int
        // String        + int
        // String
        System.out.println(str2 + 20 + 30); // Java2030
 
        System.out.println(str2 + (20 + 30)); // Java50
    }}

自增自減運算符（屬于算數(shù)運算符）

詳解

• 基本含義：讓一個變量漲一個數(shù)字1，或者讓一個變量降一個數(shù)字1

• 使用格式：寫在變量名稱之前，或者寫在變量名稱之后。例如：++i，也可以i++

使用方式：

• 單獨使用：不和其他任何操作混合，自己獨立成為一個步驟。

• 混合使用：和其他操作混合，例如與賦值混合，或者與打印操作混合，等。

使用區(qū)別：

• 在單獨使用的時候，前++和后++沒有任何區(qū)別。也就是：++i;和i++;是完全一樣的。

• 在混合的時候，有【重大區(qū)別】

• 如果是【前++】，那么變量【立刻馬上+1】，然后拿著結果進行使用。

• 如果是【后++】，那么首先使用變量本來的數(shù)值，【然后再讓變量+1】。

注意事項：

• 只有變量才能使用自增、自減運算符。常量不可發(fā)生改變，所以不能用。

• 無論是前++/--還是后++/--，只要執(zhí)行完 ++/--，最終的結果都會讓變量自加 1/ 減1 。

代碼示例

package demo;
 public class Demo {
    public static void main(String[] args) {
        int num1 = 10;
        System.out.println(num1); // 10
        ++num1; // 單獨使用，前++
        System.out.println(num1); // 11
        num1++; // 單獨使用，后++
        System.out.println(num1); // 12
 
 
        // 與打印操作混合的時候
        int num2 = 20;
        // 混合使用，先++，變量立刻馬上變成21，然后打印結果21
        System.out.println(++num2); // 21
        System.out.println(num2); // 21
 
 
        int num3 = 30;
        // 混合使用，后++，首先使用變量本來的30，然后再讓變量+1得到31
        System.out.println(num3++); // 30
        System.out.println(num3); // 31
 
 
        int num4 = 40;
        // 和賦值操作混合
        int result1 = --num4; // 混合使用，前--，變量立刻馬上-1變成39，然后將結果39交給result1變量
        System.out.println(result1); // 39
        System.out.println(num4); // 39
 
 
        int num5 = 50;
        // 混合使用，后--，首先把本來的數(shù)字50交給result2，然后我自己再-1變成49
        int result2 = num5--;
        System.out.println(result2); // 50
        System.out.println(num5); // 49
 
 
        int x = 10;
        int y = 20;
        // 11 + 20 = 31
        int result3 = ++x + y--;
        System.out.println(result3); // 31
        System.out.println(x); // 11
        System.out.println(y); // 19
 
        // 30++; // 錯誤寫法！常量不可以使用++或者--
    }}

關系運算符 

關系運算符主要是完成數(shù)據(jù)和數(shù)據(jù)之間的比較，比如：5>3，結果是 true（真），5>10， 結果是 false（假），那么關系運算符都有哪些呢？>、>=、<、<=、==、!=

注意：

• 比較運算符的結果一定是一個boolean值，成立就是true，不成立就是false。千萬不要把“==”誤寫成“=”。 

• 如果進行多次判斷，不能連著寫。數(shù)學當中的寫法，例如：1 < x < 3 程序當中【不允許】這種寫法

代碼示例

/*
        一定要記住一個規(guī)則：
            所有的關系運算符的運算結果都是布爾類型，
            不是true就是false，不可能是其他值。
        
        在java語言中:
            = ： 賦值運算符
            == ：關系運算符，判斷是否相等。
        
        注意：關系運算符中如果有兩個符號的話，兩個符號之間不能有空格。
            >= 這是對的, > = 這是不對的。
            == 這是對的，= = 這是不對的。
*/
 public class Demo {
    public static void main(String[] args) {
        System.out.println(10 > 5); // true
        int num1 = 10;
        int num2 = 12;
        System.out.println(num1 < num2); // true
        System.out.println(num2 >= 100); // false
        System.out.println(num2 <= 100); // true
        System.out.println(num2 <= 12); // true
        System.out.println("===============");
        
        System.out.println(10 == 10); // true
        System.out.println(20 != 25); // true
        System.out.println(20 != 20); // false
        
        int x = 2;
        // System.out.println(1 < x < 3); // 錯誤寫法！編譯報錯！不能連著寫。
    }}

賦值運算符

賦值類的運算符包括基本賦值運算符（=）和擴展的賦值運算符（+=、-=、*=、/=、%=）。

注意事項：

• 只有變量才能使用賦值運算符，常量不能進行賦值。

• 復合賦值運算符其中隱含了一個強制類型轉換。 

• 擴展賦值運算符在編寫的時候，兩個符號之間不能有空格。

代碼示例

/*
賦值運算符分為：
基本賦值運算符：就是一個等號“=”，代表將右側的數(shù)據(jù)交給左側的變量。賦值運算符“=”右邊優(yōu)先級比較高，先執(zhí)行右邊的表達式
    int a = 30;
復合賦值運算符：
    +=        a += 3        相當于        a = a + 3
    -=        b -= 4        相當于        b = b - 4
    *=        c *= 5        相當于        c = c * 5
    /=        d /= 6        相當于        d = d / 6
    %=        e %= 7        相當于        e = e % 7
*/public class Demo {
    public static void main(String[] args) {
        int a = 10;
        // 按照公式進行翻譯：a = a + 5
        // a = 10 + 5;
        // a = 15;
        // a本來是10，現(xiàn)在重新賦值得到15
        a += 5; 
        System.out.println(a); // 15
        
        int x = 10;
        // x = x % 3;
        // x = 10 % 3;
        // x = 1;
        // x本來是10，現(xiàn)在重新賦值得到1
        x %= 3;
        System.out.println(x); // 1
        
        // 50 = 30; // 常量不能進行賦值，不能寫在賦值運算符的左邊。錯誤寫法！
        
        byte num = 30;
        // num = num + 5;
        // num = byte + int
        // num = int + int
        // num = int
        // num = (byte) int
        num += 5;
        System.out.println(num); // 35
    }}

邏輯運算符

邏輯運算符主要包括邏輯與（&），邏輯或（|），邏輯異或（^），短路與（&&），短路或（||）。所有邏輯運算符的特點是操作數(shù)都是布爾類型，并且最終的運算結果也是布爾類型。

注意：

• 邏輯運算符用于連接布爾型表達式，在Java中不可以寫成3<x<6，應該寫 成x>3 & x<6 。

“&”和“&&”的區(qū)別：

• 單&時，左邊無論真假，右邊都進行運算；

• 雙&時，如果左邊為真，右邊參與運算，如果左邊為假，那么右邊不參與運算。

• “|”和“||”的區(qū)別同理，||表示：當左邊為真，右邊不參與運算。

異或( ^ )與或( | )的不同之處是：當左右都為true時，結果為false。

代碼示例

/*
與（并且）    &&    全都是true，才是true；否則就是false
或（或者）    ||    至少一個是true，就是true；全都是false，才是false
非（取反）    !    本來是true，變成false；本來是false，變成true
與“&&”，或“||”，具有短路效果：如果根據(jù)左邊已經(jīng)可以判斷得到最終結果，那么右邊的代碼將不再執(zhí)行，從而節(jié)省一定的性能。
注意事項：
1. 邏輯運算符只能用于boolean值。
2. 與、或需要左右各自有一個boolean值，但是取反只要有唯一的一個boolean值即可。
3. 與、或兩種運算符，如果有多個條件，可以連續(xù)寫。
兩個條件：條件A && 條件B
多個條件：條件A && 條件B && 條件C
TIPS：
對于1 < x < 3的情況，應該拆成兩個部分，然后使用與運算符連接起來：
int x = 2;
1 < x && x < 3
*/public class Demo {
    public static void main(String[] args) {
        System.out.println(true && false); // false
        // true && true --> true
        System.out.println(3 < 4 && 10 > 5); // true
        System.out.println("============");
        
        System.out.println(true || false); // true
        System.out.println(true || true); // true
        System.out.println(false || false); // false
        System.out.println("============");
        
        System.out.println(true); // true
        System.out.println(!true); // false    
        System.out.println("============");
        
        int a = 10;
        // false && ...
        System.out.println(3 > 4 && ++a < 100); // false
        System.out.println(a); // 10
        System.out.println("============");
        
        int b = 20;
        // true || ...
        System.out.println(3 < 4 || ++b < 100); // true
        System.out.println(b); // 20
    }}

三目運算符

執(zhí)行流程：

• 首先計算關系表達式的值

• 如果值為true，表達式1的值就是運算結果

• 如果值為false，表達式2的值就是運算結果

代碼示例

/*
格式：
數(shù)據(jù)類型 變量名稱 = 條件判斷 ? 表達式A : 表達式B;
流程：
首先判斷條件是否成立：
    如果成立為true，那么將表達式A的值賦值給左側的變量；
    如果不成立為false，那么將表達式B的值賦值給左側的變量；
二者選其一。
*/public class Demo{
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        
        // 數(shù)據(jù)類型 變量名稱 = 條件判斷 ? 表達式A : 表達式B;
        // 判斷a > b是否成立，如果成立將a的值賦值給max；如果不成立將b的值賦值給max。二者選其一
        int max = a > b ? a : b; // 最大值的變量
        System.out.println("最大值：" + max); // 20
        
        // int result = 3 > 4 ? 2.5 : 10; // 錯誤寫法！
        
        System.out.println(a > b ? a : b); // 正確寫法！
        
        // a > b ? a : b; // 錯誤寫法！
    }}

注意事項：

• 必須同時保證表達式A和表達式B都符合左側數(shù)據(jù)類型的要求。

• 三元運算符的結果必須被使用。

位運算符

位運算是直接對整數(shù)的二進制進行的運算 且 位運算符操作的都是整型的數(shù)據(jù)。

代碼示例

/*
結論：
1. 位運算符操作的都是整型的數(shù)據(jù)
2. << ：在一定范圍內，每向左移1位，相當于 * 2
   >> :在一定范圍內，每向右移1位，相當于 / 2
面試題：最高效方式的計算2 * 8 ？  2 << 3  或 8 << 1
*/class BitTest {
    public static void main(String[] args) {
        int i = 21;
        i = -21;
        System.out.println("i << 2 :" + (i << 2));
        System.out.println("i << 3 :" + (i << 3));
        System.out.println("i << 27 :" + (i << 27));
 
        int m = 12;
        int n = 5;
        System.out.println("m & n :" + (m & n));
        System.out.println("m | n :" + (m | n));
        System.out.println("m ^ n :" + (m ^ n));
 
        //練習：交換兩個變量的值
        int num1 = 10;
        int num2 = 20;
        System.out.println("num1 = " + num1 + ",num2 = " + num2);
 
        //方式一：定義臨時變量的方式
        //推薦的方式
        int temp = num1;
        num1 = num2;
        num2 = temp;
 
        //方式二：好處：不用定義臨時變量  
        //弊端：① 相加操作可能超出存儲范圍 ② 有局限性：只能適用于數(shù)值類型
        //num1 = num1 + num2;
        //num2 = num1 - num2;
        //num1 = num1 - num2;
 
        //方式三：使用位運算符
        //有局限性：只能適用于數(shù)值類型
        //num1 = num1 ^ num2;
        //num2 = num1 ^ num2;
        //num1 = num1 ^ num2;
 
        System.out.println("num1 = " + num1 + ",num2 = " + num2);
 
    }}

位運算符的細節(jié)

關于進制

所有數(shù)字在計算機底層都以二進制形式存在。

對于整數(shù)，有四種表示方式：

• 二進制(binary)：0,1 ，滿2進1.以0b或0B開頭。

• 十進制(decimal)：0-9 ，滿10進1。

• 八進制(octal)：0-7 ，滿8進1. 以數(shù)字0開頭表示。

• 十六進制(hex)：0-9及A-F，滿16進1. 以0x或0X開頭表示。此處的A-F不區(qū)分大小寫。 如：0x21AF +1= 0X21B0

二進制

Java整數(shù)常量默認是int類型，當用二進制定義整數(shù)時，其第32位是符號位； 當是long類型時，二進制默認占64位，第64位是符號位

二進制的整數(shù)有如下三種形式：

• 原碼：直接將一個數(shù)值換成二進制數(shù)。最高位是符號位

• 負數(shù)的反碼：是對原碼按位取反，只是最高位（符號位）確定為1。

• 負數(shù)的補碼：其反碼加1。

計算機以二進制補碼的形式保存所有的整數(shù)。

• 正數(shù)的原碼、反碼、補碼都相同

• 負數(shù)的補碼是其反碼+1

為什么要使用原碼、反碼、補碼表示形式呢？

計算機辨別“符號位”顯然會讓計算機的基礎電路設計變得十分復雜! 于是 人們想出了將符號位也參與運算的方法. 我們知道, 根據(jù)運算法則減去一個正 數(shù)等于加上一個負數(shù), 即: 1-1 = 1 + (-1) = 0 , 所以機器可以只有加法而沒有 減法, 這樣計算機運算的設計就更簡單了。

標簽：入門,int,System,day05,運算符,println,true,out
來源： https://www.cnblogs.com/wurengen/p/14008084.html