我們?cè)谌粘ｉ_(kāi)發(fā)中經(jīng)常會(huì)使用到諸如泛型、自動(dòng)拆箱和裝箱、內(nèi)部類、增強(qiáng) for 循環(huán)、try-with-resources 語(yǔ)法、lambda 表達(dá)式等，我們只覺(jué)得用的很爽，因?yàn)檫@些特性能夠幫助我們減輕開(kāi)發(fā)工作量；但我們未曾認(rèn)真研究過(guò)這些特性的本質(zhì)是什么，那么這篇文章，cxuan 就來(lái)為你揭開(kāi)這些特性背后的真相。

語(yǔ)法糖

在聊之前我們需要先了解一下語(yǔ)法糖的概念：語(yǔ)法糖（Syntactic sugar），也叫做糖衣語(yǔ)法，是英國(guó)科學(xué)家發(fā)明的一個(gè)術(shù)語(yǔ)，通常來(lái)說(shuō)使用語(yǔ)法糖能夠增加程序的可讀性，從而減少程序代碼出錯(cuò)的機(jī)會(huì)，真是又香又甜。

語(yǔ)法糖指的是計(jì)算機(jī)語(yǔ)言中添加的某種語(yǔ)法，這種語(yǔ)法對(duì)語(yǔ)言的功能并沒(méi)有影響，但是更方便程序員使用。因?yàn)?Java 代碼需要運(yùn)行在 JVM 中，JVM 是并不支持語(yǔ)法糖的，語(yǔ)法糖在程序編譯階段就會(huì)被還原成簡(jiǎn)單的基礎(chǔ)語(yǔ)法結(jié)構(gòu)，這個(gè)過(guò)程就是解語(yǔ)法糖。所以在 Java 中，真正支持語(yǔ)法糖的是 Java 編譯器，真是換湯不換藥，萬(wàn)變不離其宗，關(guān)了燈都一樣。。。。。。

下面我們就來(lái)認(rèn)識(shí)一下 Java 中的這些語(yǔ)法糖

泛型

泛型是一種語(yǔ)法糖。在 JDK1.5 中，引入了泛型機(jī)制，但是泛型機(jī)制的本身是通過(guò)類型擦除來(lái)實(shí)現(xiàn)的，在 JVM 中沒(méi)有泛型，只有普通類型和普通方法，泛型類的類型參數(shù)，在編譯時(shí)都會(huì)被擦除。泛型并沒(méi)有自己獨(dú)特的 Class類型。如下代碼所示

ListaList = new ArrayList();
ListbList = new ArrayList();

System.out.println(aList.getClass() == bList.getClass());

List和List被認(rèn)為是不同的類型，但是輸出卻得到了相同的結(jié)果，這是因?yàn)椋?strong>泛型信息只存在于代碼編譯階段，在進(jìn)入 JVM 之前，與泛型相關(guān)的信息會(huì)被擦除掉，專業(yè)術(shù)語(yǔ)叫做類型擦除。但是，如果將一個(gè) Integer 類型的數(shù)據(jù)放入到List中或者將一個(gè) String 類型的數(shù)據(jù)放在List中是不允許的。

如下圖所示

無(wú)法將一個(gè) Integer 類型的數(shù)據(jù)放在List和無(wú)法將一個(gè) String 類型的數(shù)據(jù)放在List中是一樣會(huì)編譯失敗。

自動(dòng)拆箱和自動(dòng)裝箱

自動(dòng)拆箱和自動(dòng)裝箱是一種語(yǔ)法糖，它說(shuō)的是八種基本數(shù)據(jù)類型的包裝類和其基本數(shù)據(jù)類型之間的自動(dòng)轉(zhuǎn)換。簡(jiǎn)單的說(shuō)，裝箱就是自動(dòng)將基本數(shù)據(jù)類型轉(zhuǎn)換為包裝器類型；拆箱就是自動(dòng)將包裝器類型轉(zhuǎn)換為基本數(shù)據(jù)類型。

我們先來(lái)了解一下基本數(shù)據(jù)類型的包裝類都有哪些

也就是說(shuō)，上面這些基本數(shù)據(jù)類型和包裝類在進(jìn)行轉(zhuǎn)換的過(guò)程中會(huì)發(fā)生自動(dòng)裝箱/拆箱，例如下面代碼

Integer integer = 66; // 自動(dòng)拆箱 int i1 = integer; // 自動(dòng)裝箱 

上面代碼中的 integer 對(duì)象會(huì)使用基本數(shù)據(jù)類型來(lái)進(jìn)行賦值，而基本數(shù)據(jù)類型 i1 卻把它賦值給了一個(gè)對(duì)象類型，一般情況下是不能這樣操作的，但是編譯器卻允許我們這么做，這其實(shí)就是一種語(yǔ)法糖。這種語(yǔ)法糖使我們方便我們進(jìn)行數(shù)值運(yùn)算，如果沒(méi)有語(yǔ)法糖，在進(jìn)行數(shù)值運(yùn)算時(shí)，你需要先將對(duì)象轉(zhuǎn)換成基本數(shù)據(jù)類型，基本數(shù)據(jù)類型同時(shí)也需要轉(zhuǎn)換成包裝類型才能使用其內(nèi)置的方法，無(wú)疑增加了代碼冗余。

那么自動(dòng)拆箱和自動(dòng)裝箱是如何實(shí)現(xiàn)的呢？

其實(shí)這背后的原理是編譯器做了優(yōu)化。將基本類型賦值給包裝類其實(shí)是調(diào)用了包裝類的valueOf()方法創(chuàng)建了一個(gè)包裝類再賦值給了基本類型。

int i1 = Integer.valueOf(1);

而包裝類賦值給基本類型就是調(diào)用了包裝類的 xxxValue() 方法拿到基本數(shù)據(jù)類型后再進(jìn)行賦值。

Integer i1 = new Integer(1).intValue();

我們使用 javap -c 反編譯一下上面的自動(dòng)裝箱和自動(dòng)拆箱來(lái)驗(yàn)證一下

可以看到，在 Code 2 處調(diào)用invokestatic的時(shí)候，相當(dāng)于是編譯器自動(dòng)為我們添加了一下 Integer.valueOf 方法從而把基本數(shù)據(jù)類型轉(zhuǎn)換為了包裝類型。

在 Code 7 處調(diào)用了invokevirtual的時(shí)候，相當(dāng)于是編譯器為我們添加了 Integer.intValue() 方法把 Integer 的值轉(zhuǎn)換為了基本數(shù)據(jù)類型。

枚舉

我們?cè)谌粘ｉ_(kāi)發(fā)中經(jīng)常會(huì)使用到enum和public static final ...這類語(yǔ)法。那么什么時(shí)候用 enum 或者是 public static final 這類常量呢？好像都可以。

但是在 Java 字節(jié)碼結(jié)構(gòu)中，并沒(méi)有枚舉類型。枚舉只是一個(gè)語(yǔ)法糖，在編譯完成后就會(huì)被編譯成一個(gè)普通的類，也是用 Class 修飾。這個(gè)類繼承于 java.lang.Enum，并被 final 關(guān)鍵字修飾。

我們舉個(gè)例子來(lái)看一下

public enum School {
    STUDENT,
    TEACHER;
}

這是一個(gè) School 的枚舉，里面包括兩個(gè)字段，一個(gè)是 STUDENT ，一個(gè)是 TEACHER，除此之外并無(wú)其他。

下面我們使用javap反編譯一下這個(gè) School.class 。反編譯完成之后的結(jié)果如下

從圖中我們可以看到，枚舉其實(shí)就是一個(gè)繼承于java.lang.Enum類的 class 。而里面的屬性 STUDENT 和 TEACHER 本質(zhì)也就是public static final修飾的字段。這其實(shí)也是一種編譯器的優(yōu)化，畢竟 STUDENT 要比 public static final School STUDENT 的美觀性、簡(jiǎn)潔性都要好很多。

除此之外，編譯器還會(huì)為我們生成兩個(gè)方法，values()方法和valueOf方法，這兩個(gè)方法都是編譯器為我們添加的方法，通過(guò)使用 values() 方法可以獲取所有的 Enum 屬性值，而通過(guò) valueOf 方法用于獲取單個(gè)的屬性值。

注意，Enum 的 values() 方法不屬于 JDK API 的一部分，在 Java 源碼中，沒(méi)有 values() 方法的相關(guān)注釋。

用法如下

public enum School {

    STUDENT("Student"),
    TEACHER("Teacher"); private String name;

    School(String name){ this.name = name;
    } public String getName() { return name;
    } public static void main(String[] args) {

        System.out.println(School.STUDENT.getName());

        School[] values = School.values(); for(School school : values){
            System.out.println("name = "+ school.getName());
        }

    }
}

內(nèi)部類

內(nèi)部類是 Java 一個(gè)小眾的特性，我之所以說(shuō)小眾，并不是說(shuō)內(nèi)部類沒(méi)有用，而是我們?nèi)粘ｉ_(kāi)發(fā)中其實(shí)很少用到，但是翻看 JDK 源碼，發(fā)現(xiàn)很多源碼中都有內(nèi)部類的構(gòu)造。比如常見(jiàn)的ArrayList源碼中就有一個(gè)Itr內(nèi)部類繼承于Iterator類；再比如HashMap中就構(gòu)造了一個(gè)Node繼承于 Map.Entry來(lái)表示 HashMap 的每一個(gè)節(jié)點(diǎn)。

Java 語(yǔ)言中之所以引入內(nèi)部類，是因?yàn)橛行r(shí)候一個(gè)類只想在一個(gè)類中有用，不想讓其在其他地方被使用，也就是對(duì)外隱藏內(nèi)部細(xì)節(jié)。

內(nèi)部類其實(shí)也是一個(gè)語(yǔ)法糖，因?yàn)槠渲皇且粋€(gè)編譯時(shí)的概念，一旦編譯完成，編譯器就會(huì)為內(nèi)部類生成一個(gè)單獨(dú)的class 文件，名為 outer$innter.class。

下面我們就根據(jù)一個(gè)示例來(lái)驗(yàn)證一下。

public class OuterClass { private String label; class InnerClass { public String linkOuter(){ return label = "inner";
        }

    } public static void main(String[] args) {

        OuterClass outerClass = new OuterClass();
        InnerClass innerClass = outerClass.new InnerClass();
        System.out.println(innerClass.linkOuter());

    }
}

上面這段編譯后就會(huì)生成兩個(gè) class 文件，一個(gè)是OuterClass.class，一個(gè)是OuterClass$InnerClass.class，這就表明，外部類可以鏈接到內(nèi)部類，內(nèi)部類可以修改外部類的屬性等。

我們來(lái)看一下內(nèi)部類編譯后的結(jié)果

如上圖所示，內(nèi)部類經(jīng)過(guò)編譯后的 linkOuter() 方法會(huì)生成一個(gè)指向外部類的 this 引用，這個(gè)引用就是連接外部類和內(nèi)部類的引用。

變長(zhǎng)參數(shù)

變長(zhǎng)參數(shù)也是一個(gè)比較小眾的用法，所謂變長(zhǎng)參數(shù)，就是方法可以接受長(zhǎng)度不定確定的參數(shù)。一般我們開(kāi)發(fā)不會(huì)使用到變長(zhǎng)參數(shù)，而且變長(zhǎng)參數(shù)也不推薦使用，它會(huì)使我們的程序變的難以處理。但是我們有必要了解一下變長(zhǎng)參數(shù)的特性。

其基本用法如下

public class VariableArgs { public static void printMessage(String... args){ for(String str : args){
            System.out.println("str = " + str);
        }
    } public static void main(String[] args) {
        VariableArgs.printMessage("l","am","cxuan");
    }
}

變長(zhǎng)參數(shù)也是一種語(yǔ)法糖，那么它是如何實(shí)現(xiàn)的呢？我們可以猜測(cè)一下其內(nèi)部應(yīng)該是由數(shù)組構(gòu)成，否則無(wú)法接受多個(gè)值，那么我們反編譯看一下是不是由數(shù)組實(shí)現(xiàn)的。

    可以看到，printMessage() 的參數(shù)就是使用了一個(gè)數(shù)組來(lái)接收，所以千萬(wàn)別被變長(zhǎng)參數(shù)忽悠了！

變長(zhǎng)參數(shù)特性是在 JDK 1.5 中引入的，使用變長(zhǎng)參數(shù)有兩個(gè)條件，一是變長(zhǎng)的那一部分參數(shù)具有相同的類型，二是變長(zhǎng)參數(shù)必須位于方法參數(shù)列表的最后面。

增強(qiáng) for 循環(huán)

為什么有了普通的 for 循環(huán)后，還要有增強(qiáng) for 循環(huán)呢？想一下，普通 for 循環(huán)你不是需要知道遍歷次數(shù)？每次還需要知道數(shù)組的索引是多少，這種寫(xiě)法明顯有些繁瑣。增強(qiáng) for 循環(huán)與普通 for 循環(huán)相比，功能更強(qiáng)并且代碼更加簡(jiǎn)潔，你無(wú)需知道遍歷的次數(shù)和數(shù)組的索引即可進(jìn)行遍歷。

增強(qiáng) for 循環(huán)的對(duì)象要么是一個(gè)數(shù)組，要么實(shí)現(xiàn)了 Iterable 接口。這個(gè)語(yǔ)法糖主要用來(lái)對(duì)數(shù)組或者集合進(jìn)行遍歷，其在循環(huán)過(guò)程中不能改變集合的大小。

public static void main(String[] args) {
    String[] params = new String[]{"hello","world"}; //增強(qiáng)for循環(huán)對(duì)象為數(shù)組 for(String str : params){
        System.out.println(str);
    }

    Listlists = Arrays.asList("hello","world"); //增強(qiáng)for循環(huán)對(duì)象實(shí)現(xiàn)Iterable接口 for(String str : lists){
        System.out.println(str);
    }
}

經(jīng)過(guò)編譯后的 class 文件如下

public static void main(String[] args) {
   String[] params = new String[]{"hello", "world"};
   String[] lists = params; int var3 = params.length; //數(shù)組形式的增強(qiáng)for退化為普通for for(int str = 0; str < var3; ++str) { String str1 = lists[str]; System.out.println(str1); } List var6 = Arrays.asList(new String[]{"hello", "world"});
   Iterator var7 = var6.iterator(); //實(shí)現(xiàn)Iterable接口的增強(qiáng)for使用iterator接口進(jìn)行遍歷 while(var7.hasNext()) {
       String var8 = (String)var7.next();
       System.out.println(var8);
   }

}

如上代碼所示，如果對(duì)數(shù)組進(jìn)行增強(qiáng) for 循環(huán)的話，其內(nèi)部還是對(duì)數(shù)組進(jìn)行遍歷，只不過(guò)語(yǔ)法糖把你忽悠了，讓你以一種更簡(jiǎn)潔的方式編寫(xiě)代碼。

而對(duì)繼承于 Iterator 迭代器進(jìn)行增強(qiáng) for 循環(huán)遍歷的話，相當(dāng)于是調(diào)用了 Iterator 的hasNext()和next()方法。

Switch 支持字符串和枚舉

switch關(guān)鍵字原生只能支持整數(shù)類型。如果 switch 后面是 String 類型的話，編譯器會(huì)將其轉(zhuǎn)換成 String 的hashCode的值，所以其實(shí) switch 語(yǔ)法比較的是 String 的 hashCode 。

如下代碼所示

public class SwitchCaseTest { public static void main(String[] args) {

        String str = "cxuan"; switch (str){ case "cuan":
                System.out.println("cuan"); break; case "xuan":
                System.out.println("xuan"); break; case "cxuan":
                System.out.println("cxuan"); break; default: break;
        }
    }
}

我們反編譯一下，看看我們的猜想是否正確

根據(jù)字節(jié)碼可以看到，進(jìn)行 switch 的實(shí)際是 hashcode 進(jìn)行判斷，然后通過(guò)使用 equals 方法進(jìn)行比較，因?yàn)樽址锌赡軙?huì)產(chǎn)生哈希沖突的現(xiàn)象。

條件編譯

這個(gè)又是讓小伙伴們摸不著頭腦了，什么是條件編譯呢？其實(shí)，如果你用過(guò) C 或者 C++ 你就知道可以通過(guò)預(yù)處理語(yǔ)句來(lái)實(shí)現(xiàn)條件編譯。

那么什么是條件編譯呢？

一般情況下，源程序中所有的行都參加編譯。但有時(shí)希望對(duì)其中一部分內(nèi)容只在滿足一定條件下才進(jìn)行編譯，即對(duì)一部分內(nèi)容指定編譯條件，這就是條件編譯（conditional compile）。

#define DEBUG  #IFDEF DEBUUG /* 
   code block 1 
   */ #ELSE /* 
   code block 2 
  */ #ENDIF

但是在 Java 中沒(méi)有預(yù)處理和宏定義這些內(nèi)容，那么我們想實(shí)現(xiàn)條件編譯，應(yīng)該怎樣做呢？

使用 final + if 的組合就可以實(shí)現(xiàn)條件編譯了。如下代碼所示

public static void main(String[] args) { final boolean DEBUG = true; if (DEBUG) {  
    System.out.println("Hello, world!");  
  } else {
    System.out.println("nothing");
  }
}

這段代碼會(huì)發(fā)生什么？我們反編譯看一下

我們可以看到，我們明明是使用了 if …else 語(yǔ)句，但是編譯器卻只為我們編譯了 DEBUG = true 的條件，

所以，Java 語(yǔ)法的條件編譯，是通過(guò)判斷條件為常量的 if 語(yǔ)句實(shí)現(xiàn)的，編譯器不會(huì)為我們編譯分支為 false 的代碼。

斷言

你在 Java 中使用過(guò)斷言作為日常的判斷條件嗎？

斷言：也就是所謂的assert關(guān)鍵字，是 jdk 1.4 后加入的新功能。它主要使用在代碼開(kāi)發(fā)和測(cè)試時(shí)期，用于對(duì)某些關(guān)鍵數(shù)據(jù)的判斷，如果這個(gè)關(guān)鍵數(shù)據(jù)不是你程序所預(yù)期的數(shù)據(jù)，程序就提出警告或退出。當(dāng)軟件正式發(fā)布后，可以取消斷言部分的代碼。它也是一個(gè)語(yǔ)法糖嗎？現(xiàn)在我不告訴你，我們先來(lái)看一下 assert 如何使用。

//這個(gè)成員變量的值可以變，但最終必須還是回到原值5  static int i = 5; public static void main(String[] args) { assert i == 5;  
  System.out.println("如果斷言正常，我就被打印");  
}

如果要開(kāi)啟斷言檢查，則需要用開(kāi)關(guān) -enableassertions 或 -ea 來(lái)開(kāi)啟。其實(shí)斷言的底層實(shí)現(xiàn)就是 if 判斷，如果斷言結(jié)果為 true，則什么都不做，程序繼續(xù)執(zhí)行，如果斷言結(jié)果為 false，則程序拋出 AssertError 來(lái)打斷程序的執(zhí)行。

assert 斷言就是通過(guò)對(duì)布爾標(biāo)志位進(jìn)行了一個(gè) if 判斷。

try-with-resources

JDK 1.7 開(kāi)始，java引入了 try-with-resources 聲明，將 try-catch-finally 簡(jiǎn)化為 try-catch，這其實(shí)是一種語(yǔ)法糖，在編譯時(shí)會(huì)進(jìn)行轉(zhuǎn)化為 try-catch-finally 語(yǔ)句。新的聲明包含三部分：try-with-resources 聲明、try 塊、catch 塊。它要求在 try-with-resources 聲明中定義的變量實(shí)現(xiàn)了 AutoCloseable 接口，這樣在系統(tǒng)可以自動(dòng)調(diào)用它們的 close 方法，從而替代了 finally 中關(guān)閉資源的功能。

如下代碼所示

public class TryWithResourcesTest { public static void main(String[] args) { try(InputStream inputStream = new FileInputStream(new File("xxx"))) {
            inputStream.read();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

我們可以看一下 try-with-resources 反編譯之后的代碼

可以看到，生成的 try-with-resources 經(jīng)過(guò)編譯后還是使用的 try…catch…finally 語(yǔ)句，只不過(guò)這部分工作由編譯器替我們做了，這樣能讓我們的代碼更加簡(jiǎn)潔，從而消除樣板代碼。

字符串相加

這個(gè)想必大家應(yīng)該都知道，字符串的拼接有兩種，如果能夠在編譯時(shí)期確定拼接的結(jié)果，那么使用+號(hào)連接的字符串會(huì)被編譯器直接優(yōu)化為相加的結(jié)果，如果編譯期不能確定拼接的結(jié)果，底層會(huì)直接使用StringBuilder的append進(jìn)行拼接，如下圖所示。

public class StringAppendTest { public static void main(String[] args) {
        String s1 = "I am " + "cxuan";
        String s2 = "I am " + new String("cxuan");
        String s3 = "I am ";
        String s4 = "cxuan";
        String s5 = s3 + s4;

    }
}

上面這段代碼就包含了兩種字符串拼接的結(jié)果，我們反編譯看一下

首先來(lái)看一下 s1 ，s1 因?yàn)?= 號(hào)右邊是兩個(gè)常量，所以兩個(gè)字符串拼接會(huì)被直接優(yōu)化成為I am cxuan。而 s2 由于在堆空間中分配了一個(gè) cxuan 對(duì)象，所以 + 號(hào)兩邊進(jìn)行字符串拼接會(huì)直接轉(zhuǎn)換為 StringBuilder ，調(diào)用其 append 方法進(jìn)行拼接，最后再調(diào)用 toString() 方法轉(zhuǎn)換成字符串。

而由于 s5 進(jìn)行拼接的兩個(gè)對(duì)象在編譯期不能判定其拼接結(jié)果，所以會(huì)直接使用 StringBuilder 進(jìn)行拼接。

學(xué)習(xí)語(yǔ)法糖的意義

互聯(lián)網(wǎng)時(shí)代，有很多標(biāo)新立異的想法和框架層出不窮，但是，我們對(duì)于學(xué)習(xí)來(lái)說(shuō)應(yīng)該抓住技術(shù)的核心。然而，軟件工程是一門協(xié)作的藝術(shù)，對(duì)于工程來(lái)說(shuō)如何提高工程質(zhì)量，如何提高工程效率也是我們要關(guān)注的，既然這些語(yǔ)法糖能輔助我們以更好的方式編寫(xiě)備受歡迎的代碼，我們程序員為什么要抵制呢？

語(yǔ)法糖也是一種進(jìn)步，這就和你寫(xiě)作文似的，大白話能把故事講明白的它就沒(méi)有語(yǔ)言優(yōu)美、酣暢淋漓的把故事講生動(dòng)的更令人喜歡。

我們要在敞開(kāi)懷抱擁抱變化的同時(shí)也要掌握其屠龍之技。