摘要：自動拆箱用賦值運算符把一個包裝類賦值給一個基本類型變量，或者是在包裝類進行數值運算時。指數計數，表示的冪按位操作符可以把值看成單比特值對待，的操作相同，但是不能用于布爾值。移位操作符高位包括符號位舍棄，低位補零。

System.out.println("imbug");

通過編寫一個小類庫，并通過import static該方法來實現簡化打印（基本沒啥用）。

public class Print {
    public static void println(String str) {
        System.out.println(str);
    }
}

import static s1.Print.println;

public class Test {
    public static void main(String[] args) {
        println("imbug");
    }
}

操作符接受一個或多個參數，并生成一個新值

有些操作符可能會改變操作數本身的值

幾乎所有的操作符都只能操作基本類型；=、==、!=能操作所有的對象；String類支持+、+=操作符

操作符是有優先級的。

個人認為：死記硬背操作符的優先級除了應付大學考試和智障筆試題之外，并無卵用～只要理解了運算符的原理再來看優先級有易如反掌了～

如果有人寫這樣的代碼請打死他：System.out.println(a<<=b+=c>>=5);

System.out.println()中的+運算符可能會表示字符串拼接，還有可能進行字符串轉換。

賦值=的意思是取右邊的值把它復制給左邊。
左邊的值必須是明確的、已命名的變量。
右值可以是任何常熟、變量或者表達式（只要它能生成一個值）。
基本類型傳遞的是值，對象類型傳遞的是引用。

+、-、*、/、%
/：整數的除法會直接干掉小數位而不是四舍五入
+、-：還可以用作正負號

++、--
前綴式：++a先執行運算再生成值，即++a == a is true
后綴式：a++先生成值再執行運算，即a == a++ is true

>、<、>=、<=、!=、==

關系操作符生成的是一個boolean的結果。

大于、小于、大于等于、小于等于不適用于boolean類型

等于和不等于適應于全部基本數據類型及對象類型

等于和不等于作用于對象類型時比較的是引用（我更傾向于用C++中的地址來理解這個概念）

對基本數據類型的包裝類、String、BigInteger、BigDecimal的equals方法比較的是值

如果你自己的class沒有重寫equals方法，那么equals方法使用的是Object的equals方法，即比較引用。

    Integer x1 = new Integer(10);
    Integer x2 = new Integer(10);
    System.out.println("x1 == x2: " + (x1 == x2));
    System.out.println("x1.equals(x2): " + x1.equals(x2));
    // x1 == x2: false
    // x1.equals(x2): true
    Integer y1 = 10;
    Integer y2 = 10;
    System.out.println("y1 == y2: " + (y1 == y2));
    System.out.println("y1.equals(y2): " + y1.equals(y2));
    // y1 == y2: true
    // y1.equals(y2): true
    Integer z1 = 1000;
    Integer z2 = 1000;
    System.out.println("z1 == z2: " + (z1 == z2));
    System.out.println("z1.equals(z2): " + z1.equals(z2));
    //z1 == z2: false
    //z1.equals(z2): true

上述代碼的.class文件反編譯后的代碼

    Integer x1 = new Integer(10);
    Integer x2 = new Integer(10);
    System.out.println((new StringBuilder()).append("x1 == x2: ").append(x1 == x2).toString());
    System.out.println((new StringBuilder()).append("x1.equals(x2): ").append(x1.equals(x2)).toString());
    Integer y1 = Integer.valueOf(10);
    Integer y2 = Integer.valueOf(10);
    System.out.println((new StringBuilder()).append("y1 == y2: ").append(y1 == y2).toString());
    System.out.println((new StringBuilder()).append("y1.equals(y2): ").append(y1.equals(y2)).toString());
    Integer z1 = Integer.valueOf(1000);
    Integer z2 = Integer.valueOf(1000);
    System.out.println((new StringBuilder()).append("z1 == z2: ").append(z1 == z2).toString());
    System.out.println((new StringBuilder()).append("z1.equals(z2): ").append(z1.equals(z2)).toString());

通過new Integer新建對象

new Integer每次都會新建對象，所以==的結果為false

自動裝箱與拆箱

自動裝箱：用賦值運算符=把一個數值或基本類型變量賦值給一個包裝類變量(Integer y1 = 10)。裝箱調用的是Integer.valueOf(10)方法。

自動拆箱：用賦值運算符=把一個包裝類賦值給一個基本類型變量（int y3 = y1），或者是在包裝類進行數值運算時。拆箱調用的是Integer#intValue()方法。

裝箱方法的坑（筆面試題）：下面是Integer.valueOf(int i)的源代碼。可以看出當裝箱的數值在-128到127之間是，返回的對象是IntegerCache中提前new出來的對象，所以y1 == y2的結果是true；當裝箱的數值超出該范圍，則返回的是new出來的對象，所以z1 == z2的結果為false。

其他的裝箱方法：Byte、Short、Integer、Long的范圍都是[-128,127]；Character的范圍是[0,127]；Float、Double全部是new出來的新對象；Boolean都是預定義好的true和false。有趣的是，這些代碼作者是一樣的，但寫法各不相同。

    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

備注內容：可以從https://varaneckas.com/jad/下...；或者可用從http://jd.benow.ca/下載反編譯...

&&、||、!

邏輯運算符只能根據兩個布爾值參數的邏輯關系，生成一個布爾值。

布爾值短路

即一旦能夠明確無誤地確定整個表達式的值，就不再計算表達式剩余的部分了

&&：遇到第一個false則不執行后邊的代碼

||：遇到第一個true則不執行后邊的代碼

    public static boolean func1() {
        System.out.println("func1");
        return true;
    }

    public static boolean func2() {
        System.out.println("func2");
        return false;
    }

    public static boolean func3() {
        System.out.println("func3");
        return true;
    }
    if(func1() && func2() && func3());  // 不執行func3中的內容
    if(func1() || func2() || func3());  // 不執行func2和fanc3中的內容

面試題：如何不使用條件語句控制流程。

    // 不使用if來控制該流程
    if(func1()) {
        func2();
    }
    // 方法
    boolean var = func1() && func2();

前綴0x、0X：表示16進制數字

前綴0：表示8進制數字

后綴l、L：表示long類型。在寫代碼的時候，由于小寫的l容易和數字1混淆，所以各種規范中都不建議（禁止）使用小寫的l表示長整數。最簡單就全部用大寫就好了！

后綴f、F：表示float類型。

后綴d、D：表示double類型。

e、E：指數計數，表示10的冪

&、|、^、～
&=、|=、^=

boolean：可以把boolean值看成單比特值對待，&、|、^的操作相同，但是～不能用于布爾值。

<<：高位（包括符號位）舍棄，低位補零。
>>：有符號右移運算，若高位是1，則高位補1；若高位是0，則高位補0。
>>>：無符號右移，最高位補0。

移位操作符只能用來處理整數類型。

char、byte、short進行移位操作時，會先被轉成int類型，并且結果也是int類型

long類型移位還是long

<<=、>>=、>>>=

注意：在對byte、short進行>>>=無符號右移等于運算時，整個流程是先向上轉化成int——進行移位運算——向下轉化（強制截取）成byte或short，所以會導致移位后對結果不正確。

    short s = -1;
    System.out.println(Integer.toBinaryString(s));
    // 11111111111111111111111111111111
    System.out.println(Integer.toBinaryString(s >>> 10));
    // 1111111111111111111111
    s >>>= 10;
    System.out.println(Integer.toBinaryString(s));
    // 11111111111111111111111111111111

boolean-exp ? val1 : val2

+、+=

Java中if、while語句必須使用boolean值，所以不會出現==被寫成=的問題；除非是兩個boolean值

Java編譯器也能夠防止邏輯與或（&&、||）和按位與或（&、|）的問題，除非是兩個boolean值

既可以對數值進行轉換，也可以對數值變量進行轉化

向下轉化必須要強制轉化，否則編譯失敗（移位等于、算數等于時不會）

向上轉化不必顯示進行轉化

除布爾值之外，其他類型都可以互相轉化

浮點數轉成整數值的時候直接截尾，不會進行四舍五入

表達式的最大數據類型決定了表達式的數據類型

Java所有基本數據類型的size是確定的，所以不需要sizeof

char、byte、short在使用算術操作符和移位操作符的時候都會被轉成int，必須顯示類型轉換回原來的類型。以下注釋掉的都是編譯錯誤的。

    short s1 = 10;
    short s2 = 10;
    // short s3 = s1 + s2;
    // short s4 = s1 >> 1;

char、byte、short在進行復合賦值運算（移位等于、算數等于）時不需要強制轉化。

int類型要小心結果溢出

除boolean外，任何基本類型都可以通過類型轉換變成其他基本類型

必須留意向下轉化的的結果，因為可能存在丟失信息的可能性