引言 JDK中提供了自增運算符++，自減運算符 。這兩個操作符各有兩種使用方式：首碼式（++ a, a），尾碼式（a++，a ）。可能說到這裡，說不得有讀者就會吐槽說，前尾碼式都挺簡單的，首碼式不就是先進行+1（或 1），然後再使用該值參與運算嘛，尾碼式則相反。有必要長篇大論 ...
引言
JDK中提供了自增運算符++，自減運算符--。這兩個操作符各有兩種使用方式：首碼式（++ a,--a），尾碼式（a++，a--）。可能說到這裡，說不得有讀者就會吐槽說，前尾碼式都挺簡單的，首碼式不就是先進行+1（或-1），然後再使用該值參與運算嘛，尾碼式則相反。有必要長篇大論嗎？
前尾碼式的區別確實是這樣，最起碼錶面上理解起來是這樣，但是更深入的理解就不是這麼簡單了，甚至嚴重影響到你的程式的正確性。不信，接下去看吧！
1. 首碼式 與 尾碼式的真正區別
在Java中，運算是從左往右計算的，並且按照運算符的優先順序，逐一計算出表達式的值，並用這個值參與下一個表達式的運算，如：1+2+3，其實是先計算出1+2表達式的值為3，再參與下一個表達式的運算(1+2)+3，即3+3。再如判斷if(a+2==3)。如此類推。
a++是一個表達式 ，那麼a++就會有一個表達式的計算結果，這個計算結果就是a的舊值（加1前的值）。相對的，++a表達式的計算結果a加1後的值。所以，自增的首碼形式與尾碼形式的本質區別是：表達式的值（運算結果） 是加1前的變數的值還是加1後的變數的值（自減也是如此）。並不是先加1 與 後加1的區別，或者說，前尾碼形式都是先加1（減1）的，才得到表達式的值，再參與下一步運算。因為這是一個表達式，必須先計算完表達式的運算，最後才會得到表達式的值
我們來看一個面試經常遇到的問題：
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++的步驟可以描述成 ：1> 先取a加1，將結果存儲在臨時空間；2>將結果賦給a。所以，自增自減運算符包含兩個操作：一個加1（減1）的操作和一個賦值的操作
這個原理好像對我的編程沒有用吧？不是的，在單線程的環境下，你可以不管這個細節。但在多線程的情況下，你就得時刻牢記這個細節了。要知道，自增自減不是原子性操作，也就是說不是線程安全的運算。因此，在多線程下，如果你要對共用變數實現自增自減操作，就要加鎖，或者使用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” 也是如此。
總結：
- 編譯器在分析字元時，會儘可能多地結合成有效字元，但有可能會出現語法錯誤。
- 貪心規則是有用的，特別編譯器是對轉義字元的處理。
