引言

??JDK中提供了自增運算符++，自減運算符--。這兩個操作符各有兩種使用方式：前綴式（++ a,--a），後綴式（a++，a--）。可能說到這裏，說不得有讀者就會吐槽說，前後綴式都挺簡單的，前綴式不就是先進行+1（或-1），然後再使用該值參與運算嘛，後綴式則相反。有必要長篇大論嗎？
??前後綴式的區別確實是這樣，最起碼表面上理解起來是這樣，但是更深入的理解就不是這麽簡單了，甚至嚴重影響到你的程序的正確性。不信，接下去看吧！

1、java中前綴式和後綴式的真正區別

??在Java中，運算是從左往右計算的，並且按照運算符的優先級，逐一計算出表達式的值，並用這個值參與下一個表達式的運算，如：1+2+3

我們來看一個面試經常遇到的問題：

int a = 5;
a = a++;//此時a的值是多少？

??有猜到a的值嗎？我們用上面所學到的分析一下：a=a++可以理解成以下幾個步驟：

1、計算a自加1，即 a=a+1

2、計算表達式的值，因為這是後綴形式，所以a++表達式的值就是加1前a的值(值為5)；

3、將表達式的值賦值給a，即a=5。

所以最後a的值是5。

同理，如果改成a = ++a;，則a的值是6。這是因為++a表達式的值是加1後的a，即為6。

2、自增和自減是兩個操作，不是線程安全的

??自增、自減運算符本質上不是一個計算操作，而是兩個計算操作。以a++為例，這個運算將會編譯器解析成：a=a+1，即包含兩個單目運算符（+、=）,一個單目運算符的計算操作可以看作是一個原子性操作。a++

??這個原理好像對我的編程沒有用吧？不是的，在單線程的環境下，你可以不管這個細節。但在多線程的情況下，你就得時刻牢記這個細節了。要知道，自增自減不是原子性操作，也就是說不是線程安全的運算。因此，在多線程下，如果你要對共享變量實現自增自減操作，就要加鎖，或者使用JDK提供的原子操作類（如AtomincInteger，AtomicLong等）提供的原子性自增自減方。

來看個例子，驗證一下。下面的例子提供三個靜態變量（一個是原子操作類），創建了10個線程，每個線程都對這三個變量以不同的方式進行加1操作,並循環1000次。

public class MyTest {
    static int a = 0;
    static int b = 0;
    //原子性操作類
    static AtomicInteger atomicInt = new AtomicInteger(0);
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {//創建10個線程
            Thread t = new Thread() {
                @Override                public void run() {
                    for (int j = 0; j < 1000; j++) {//計算1000次
                        a = a + 1;
                        b++;
                        atomicInt.incrementAndGet();//自增的原子性方法
                    }
                }
            };
            t.start();
        }
        // 判斷當前的活動線程是不是只有main線程，以確保10個計算線程執行完成。
        while (Thread.activeCount() > 1) {
            Thread.sleep(1000);
        }
        System.out.println("a=a+1在多線程下的結果是：" + a);
        System.out.println("b++在多線程下的結果是：" + b);
        System.out.println("原子操作類AtomicInteger在多線程下的結果是：" + atomicInt.get());
    }
}

運行結果：

a=a+1在多線程下的結果是：8883
b++在多線程下的結果是：8974
原子操作類AtomicInteger在多線程下的結果是：10000

??從運行的結果可以看出，a=a+1、b++不是線程安全的，沒有計算出正確的結果10000。也就是說這兩個表達式都不是原子性操作。事實上，它們都包含了兩個計算操作。

3、a+++b表達式引發的思考

??看到這個表達式，真的很讓人疑惑：編譯器是怎麽解析的，是解析成

a++ + b

還是

a+ ++b

真糾結，幹脆直接在編譯器上跑一趟，看看結果吧！

 int a = 5;
    int b = 5;
    int c=a+++b;
    System.out.println("a的值是: "+a);
    System.out.println("b的值是: "+b);

運行結果：

a的值是: 6
b的值是: 5

??從結果可以確認，a+++b 其實是解析成了 a++ +b，為什麽要這樣結合呢？其實有兩點原因：

• Java中的運算是從左往右進行的；

• java編譯器有一種規則——貪心規則。也就是說，編譯器會盡可能多地結合有效的符號。

那麽，a+++b這樣的結合方式就可以解釋了

但是這種結合是：盡可能多的結合，而不管這樣的結合是否合法。如：

a--b

會被編譯器解析成

a-- b

盡管這是不合法，但編譯器還是這樣處理了，這就導致編譯不通過，產生編譯錯誤。

編譯器為什麽要采用貪心規則呢？

??從上面的分析來看，貪心規則在編程中也不好利用。那麽，貪心規則的主要目的是為了什麽？
??貪心規則的主要目的就是為了分析String字符串，看看下面的例子就會明白：

    String s = "\17";
    System.out.println("\\17 轉義字符的值是："+s+"  長度是："+s.length());
    s = "\171";
    System.out.println("\\171 轉義字符的值是："+s+"  長度是："+s.length());
    s = "\1717";
    System.out.println("\\1717 轉義字符的值是："+s+"  長度是："+s.length());
    s = "\17178";
    System.out.println("\\17178 轉義字符的值是："+s+"  長度是："+s.length());

運行結果：

\17 轉義字符的值是： ??長度是：1
\171 轉義字符的值是：y ??長度是：1
\1717 轉義字符的值是：y7 ??長度是：2
\17178 轉義字符的值是：y78 ??長度是：3

??“\17” 經轉義得到一個特殊字符 “” 。而“\171” 轉義後也得到一個字符 “y”。但 “\1717”、“\17178” 得到的字符串大於1，不再是一個字符，分別是 “y7”、“y78”。

??也就是說,“\1717” 字符串只轉義了“\171” 部分，再鏈接 “7” 部分。“\17178” 字符串只轉義了 “\171” 部分,再連接 “78”。

??那為什麽 “\171” 為什麽不轉義 ”\17“ 部分，再鏈接 ”1“ 呢，而是作為一個整體進行轉義的字符串呢？

??這就是 ”貪心規則“ 所決定的。八進制的轉義字符的取值範圍是 \0~\377。所以解析 ”\171“ 字符串時，編譯器盡可能多地結合字符成一個轉移字符，”\171“ 還在取值範圍內，所以就是一個字符。但 ”\1718” 字符串，最多結合前4個字符成一個有效的轉義字符 “\171”，而“\1717” 已經超出取值範圍，不是有效字符，所以最後解析成 “\171” + "7" 的結果。“17178” 也是如此。

4、總結

• 編譯器在分析字符時，會盡可能多地結合成有效字符，但有可能會出現語法錯誤。

• 貪心規則是有用的，特別編譯器是對轉義字符的處理。

出處：http://www.cnblogs.com/jinggod/p/8424808.html

文章有不當之處，歡迎指正，你也可以關註我的微信公眾號：`好好學java`，獲取優質學習資源。

java基礎(二) 自增自減與貪心規則