幾乎各種語(yǔ)言都會(huì)或多或少的提供一些語(yǔ)法糖來方便程序員的代碼開發(fā)，這些語(yǔ)法糖雖然不會(huì)提供實(shí)質(zhì)性的功能改進(jìn)查描，但是他們或能提高效率，或能提升語(yǔ)法的嚴(yán)謹(jǐn)性，或能減少編碼出錯(cuò)的機(jī)會(huì)钝的。不過也有一種觀點(diǎn)認(rèn)為語(yǔ)法糖并不一定是有益的，大量添加和使用語(yǔ)法糖铆遭，容易讓程序員產(chǎn)生依賴硝桩，無法看清語(yǔ)法糖的糖衣背后，程序代碼的真正面目枚荣。

泛型和類型擦除

泛型是在JDK1.5的一項(xiàng)新增特性碗脊，它的本質(zhì)是參數(shù)化的類型的應(yīng)用，也就是說所操作的數(shù)據(jù)類型指定為一個(gè)參數(shù)橄妆。這種參數(shù)類型可以用在類衙伶、接口和方法的創(chuàng)建中祈坠，分別稱為泛型類、泛型接口矢劲、泛型方法赦拘。

泛型思想早在C++語(yǔ)言的模板中就開始萌芽，在Java語(yǔ)言處于還沒有出現(xiàn)泛型版本時(shí)芬沉，只能通過Object是所有類型的父類和類型強(qiáng)制轉(zhuǎn)換兩個(gè)特點(diǎn)來配合實(shí)現(xiàn)類型泛化躺同。例如，在哈希表的存取中丸逸，JDK1.5之前使用HashMap的get方法笋籽，返回值就是一個(gè)Object對(duì)象，由于Java語(yǔ)言里面所有的類型都繼承與java.lang.Object椭员，所以O(shè)bject轉(zhuǎn)型成任何對(duì)象都是有可能的车海。但是也因?yàn)橛袩o限種可能，就只有程序員和運(yùn)行期的虛擬機(jī)才知道Object到底是什么對(duì)象隘击。在編譯期間侍芝，編譯器無法檢查到這個(gè)Object的強(qiáng)制類型轉(zhuǎn)換是否成功，如果僅僅依賴程序員去保障這項(xiàng)操作的正確性的話埋同，會(huì)有許多ClassCastException的風(fēng)險(xiǎn)轉(zhuǎn)嫁到程序運(yùn)行期間州叠。

泛型在Java和C#中的使用方式看似相同，但實(shí)際上卻有著根本性的分歧凶赁。C#里面泛型無論在程序源碼中咧栗、編譯后的IL中（Intermediate Language，中間語(yǔ)言虱肄，這時(shí)候泛型是一個(gè)占位符）致板，或是運(yùn)行期的CLR中，都是切實(shí)存在的咏窿， List<int> 與 List<String> 就是兩個(gè)不同的類型斟或，它們?cè)谙到y(tǒng)運(yùn)行期生成，有自己的虛方法表和類型數(shù)據(jù)集嵌，這種實(shí)現(xiàn)稱為類型膨脹萝挤，基于這種方法實(shí)現(xiàn)的泛型稱為真實(shí)泛型。

Java中的泛型則不一樣根欧，它只在程序源碼中存在怜珍，在編譯后的字節(jié)碼文件中，就已經(jīng)替換成原來的原生類型了凤粗，并且在相應(yīng)的地方插入了強(qiáng)制轉(zhuǎn)型代碼酥泛，因此，對(duì)于運(yùn)行期的Java語(yǔ)言來說，ArrayList<Integer> 和ArrayList<String> 就是同一個(gè)類型揭璃，所以泛型技術(shù)實(shí)際上是Java語(yǔ)言的一顆語(yǔ)法糖晚凿，Java語(yǔ)言中的泛型實(shí)現(xiàn)方法稱為類型擦除，基于這種方法實(shí)現(xiàn)的泛型稱為偽泛型瘦馍。

看一段簡(jiǎn)單的源碼：

public class HH {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
    }
}

將這段Java代碼編譯成Class文件歼秽，然后再用字節(jié)碼反編譯工具進(jìn)行反編譯后，會(huì)發(fā)現(xiàn)泛型都不見了情组，程序又變回了Java泛型出現(xiàn)之前的寫法燥筷，泛型類型都變回了原生類型，如下所示：

public class HH {
    public HH() {
    }

    public static void main(String[] var0) {
        ArrayList var1 = new ArrayList();
        var1.add("1");
        var1.add("2");
        var1.add("3");
    }
}

當(dāng)初JDK設(shè)計(jì)團(tuán)隊(duì)為什么選擇類型擦除的方式來實(shí)現(xiàn)Java語(yǔ)言的泛型院崇？這個(gè)不得而知肆氓，但是確實(shí)有不少人對(duì)Java語(yǔ)言提供的偽泛型頗有微詞。在當(dāng)時(shí)眾多批評(píng)之中底瓣，有一些比較表面的谢揪，還有一些從性能上說泛型會(huì)由于強(qiáng)制轉(zhuǎn)換操作和運(yùn)行期缺少針對(duì)類型的優(yōu)化等從而導(dǎo)致比C#的泛型要慢，則是完全偏離了方向捐凭，姑且不論Java泛型是不是真的會(huì)比C#泛型慢拨扶，選擇從性能的角度評(píng)價(jià)用于提升語(yǔ)義準(zhǔn)確性的泛型思想就不太恰當(dāng)。但是在某些場(chǎng)景下茁肠，通過擦除法來實(shí)現(xiàn)泛型喪失了一些泛型思想應(yīng)有的優(yōu)雅：

public class HH {
    static void method(List<String> list) {

    }

    static void method(List<Integer> list) {

    }
}

這段代碼是不能被編譯的患民，因?yàn)長(zhǎng)ist<Integer>和List<String>編譯之后都會(huì)被擦除，變成了一樣的原生類型List<E>垦梆，擦除動(dòng)作導(dǎo)致這兩種方法的特征簽名變得一模一樣匹颤。

但是在JDK1.6的環(huán)境下（JDK1.7和JDK1.8均是不可以的 ），下面的情況也是可以被編譯的托猩。

public class HH {
    static String method(List<String> list) {
        return "";
    }

    static int method(List<Integer> list) {
        return 1;
    }

    public static void main(String[] args) {
        String s = method(new ArrayList<String>());
        int i = method(new ArrayList<Integer>());
    }
}

重載當(dāng)然不是根據(jù)返回值確定的印蓖，之所以這次能被編譯和執(zhí)行，是因?yàn)閮蓚€(gè)method方法加入了不同的返回值后才能共存在一個(gè)Class文件中站刑。Class文件方法表（method_info）的數(shù)據(jù)結(jié)構(gòu)中另伍，方法重載要求方法具備不同的特征簽名鼻百，返回值并不包含在方法的特征簽名之中绞旅，所以返回值不參與重在選擇，但是在Class文件格式之中温艇，只要描述符不是完全一致的兩個(gè)方法就可以共存因悲。也就是說，兩個(gè)方法如果有相同的名稱和特征簽名勺爱，但返回值不同晃琳，那它們也是可以合法共存于一個(gè)Class文件中的。

自動(dòng)裝箱、拆箱卫旱、遍歷循環(huán)

從純技術(shù)的角度講人灼，自動(dòng)裝箱、自動(dòng)拆箱和循環(huán)遍歷（Foreach遍歷）這些語(yǔ)法糖顾翼，無論是實(shí)現(xiàn)上還是思想上都不能和泛型相比投放，兩種的難度和深度有很大差距
。如下展示的是自動(dòng)裝箱适贸、拆箱與遍歷循環(huán)灸芳。

public class HH {
    public static void main(String[] args) {
        List<Integer> arrayList = Arrays.asList(1, 2, 5, 14, 5);
        int sum = 0;
        for (Integer integer : arrayList) {
            sum += integer;
        }
        System.out.println(sum);
    }
}

反編譯后的結(jié)果如下所示，需要注意的是拜姿，不同的反編譯器反編譯后的結(jié)果是不同的烙样。

public class HH
{
    public static void main(String[] paramArrayOfString)
    {
        List localList = Arrays.asList(new Integer[] { 
                Integer.valueOf(1), 
                Integer.valueOf(2), 
                Integer.valueOf(5), 
                Integer.valueOf(14), 
                Integer.valueOf(5) });
        int var2 = 0;

        Integer var4;
        for(Iterator var3 = var1.iterator(); var3.hasNext(); var2 += var4) {
            var4 = (Integer)var3.next();
        }

        System.out.println(var2);
    }
}

上面的代碼中包含了泛型、自動(dòng)裝箱蕊肥、自動(dòng)拆箱谒获、循環(huán)遍歷和變長(zhǎng)參數(shù)，自動(dòng)裝箱和拆箱在變異后被轉(zhuǎn)化成了對(duì)應(yīng)的包裝和還原方法壁却，例如Integer.valueOf()究反，而遍歷循環(huán)則把代碼還原成了迭代器的實(shí)現(xiàn)，這也是為何遍歷循環(huán)需要被遍歷的類實(shí)現(xiàn)Iterable接口的原因儒洛。最后看看變長(zhǎng)參數(shù)精耐，它在調(diào)用的時(shí)候變成了一個(gè)數(shù)組類型的參數(shù)，在變長(zhǎng)參數(shù)出現(xiàn)之前琅锻，程序員就是使用數(shù)組來完成類似功能的卦停。

關(guān)于自動(dòng)裝箱

public static void main(String[] args) {
    Integer a = 1;
    Integer b = 2;
    Integer c = 3;
    Integer d = 3;
    Integer e = 321;
    Integer f = 321;
    Long g = 3L;
    System.out.println(c == d);
    System.out.println(e == f);
    System.out.println(c == (a + b));
    System.out.println(c.equals(a + b));
    System.out.println(g == (a + b));
    System.out.println(g.equals(a + b));
}
打印結(jié)果：
true
false
true
true
true
false

鑒于包裝類的“==”運(yùn)算在遇不到算數(shù)運(yùn)算的情況下不會(huì)自動(dòng)拆箱，以及它們的equals方法不處理數(shù)據(jù)轉(zhuǎn)型的關(guān)系恼蓬，建議在實(shí)際編碼中盡量避免這樣使用自動(dòng)裝箱和拆箱惊完。但是打印結(jié)果的前兩條還是有些匪夷所思，看一看編譯后的代碼处硬，能發(fā)現(xiàn)一些問題：

public static void main(String[] paramArrayOfString)
{
    Integer localInteger1 = Integer.valueOf(1);
    Integer localInteger2 = Integer.valueOf(2);
    Integer localInteger3 = Integer.valueOf(3);
    Integer localInteger4 = Integer.valueOf(3);
    Integer localInteger5 = Integer.valueOf(321);
    Integer localInteger6 = Integer.valueOf(321);
    Long localLong = Long.valueOf(3L);
    int i = 3;
    System.out.println(localInteger3 == localInteger4);
    System.out.println(localInteger5 == localInteger6);
    System.out.println(localInteger3.intValue() == localInteger1.intValue() + localInteger2.intValue());
    System.out.println(localInteger3.equals(Integer.valueOf(localInteger1.intValue() + localInteger2.intValue())));
    System.out.println(localLong.longValue() == localInteger1.intValue() + localInteger2.intValue());
    System.out.println(localLong.equals(Integer.valueOf(localInteger1.intValue() + localInteger2.intValue())));
    System.out.println(i == 3);
}

Integer在初始化的時(shí)候小槐，其實(shí)是調(diào)用了Integer.valueOf()方法，如下：

    /**
     * Returns an {@code Integer} instance representing the specified
     * {@code int} value.  If a new {@code Integer} instance is not
     * required, this method should generally be used in preference to
     * the constructor {@link #Integer(int)}, as this method is likely
     * to yield significantly better space and time performance by
     * caching frequently requested values.
     *
     * This method will always cache values in the range -128 to 127,
     * inclusive, and may cache other values outside of this range.
     *
     * @param  i an {@code int} value.
     * @return an {@code Integer} instance representing {@code i}.
     * @since  1.5
     */
    public static Integer valueOf(int i) {
        assert IntegerCache.high >= 127;
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

注釋中明確指出荷辕，如果數(shù)值在-128~127中間的話凿跳，將使用緩存值，其他數(shù)值會(huì)創(chuàng)建新的Integer對(duì)象疮方，因此c和d的比較其實(shí)就是Integer緩存的比較控嗜，而非對(duì)象和對(duì)象之間的比較，故返回的是true骡显。