什么是泛型？

泛型是指通用的數據類型，泛型的本質是參數化類型，也就是說所操作的數據類型被指定為一個參數。這種參數類型可以用在類、接口和方法的創建中，分別稱為泛型類、泛型接口、泛型方法。泛型在Java中的應用主要有兩種：對集合對象進行類型安全檢查和編寫通用Java程序（Java框架）。

泛型的的使用

在介紹泛型在Java中的應用之前，先簡單介紹一下泛型是如何使用的。泛型被使用最多的地方是泛型化集合類（集合類包括List、Set、Map等類及其實現類）。使用泛型來聲明集合對象時，就規定了集合中元素的數據類型。舉個例子，如果要聲明一個元素數據類型為String的ArrayList數組，語法為：

List<String> list = new ArrayList<String>();

泛型化集合類的語法為：

集合類<泛型類型> 集合對象名 = new 集合類的實現類<泛型類型>();

注意一下，泛型是JDK1.5（即JDK5）中的新特性，現在的Java教程大部分都是采JDK1.5或者更新的版本，因此在介紹實例化集合類的時候就是采用的上面的聲明語法 ，實際上這就運用了泛型。
此外，在泛型化集合類的語法代碼中，前后的兩個泛型類型必須一致，如下圖：

泛型類型不匹配

即使Number是Integer的父類，仍然不允許這樣聲明。

類型安全檢查

前面說過泛型是Java1.5的新特性，那么在Java1.5之前，由于沒有泛型，因此可以向集合添加任何數據類型的元素，另外，從集合中取出元素 時，數據類型丟失，這時必須要使用與數據類型相關的方法，進行強制類型轉換。聲明集合對象的語法十分簡單，為：

集合類 集合對象名 = new 集合類的實現類();

舉個例子，先聲明一個ArrayList數組，再向里面添加不同數據類型的元素，然后遍歷這個數組，打印每一個元素，因此代碼為：

public class GenericTest {
    @Test
    public void demo1() {
        List list = new ArrayList();
        list.add("abc");
        list.add(123);
        for (int i = 0; i < list.size(); i++) {
        Object o = list.get(i);
        String s = (String) o;
        System.out.println(s);
        }
    }
}

由于沒有泛型，數組中每一個元素的數據類型都為Object，所以為了輸出abc需要強制將Object型轉換成String類型，然而并不是每一個元素都是以String型保存在數組中的。用JUnit進行單體測試，很顯然程序會報錯：

數據類型報錯

原因很簡單，123不是以String型保存在數組中的，就無法強制轉換為String型，如果想要正確地遍歷數組并輸出，就只能根據元素保存在數組中的數據類型一個個地進行強制類型轉換，如果數組中的元素很多，這樣做就會極大地降低效率。
另外，當我們用最原始的方法進行Java編譯時，如果不使用泛型，就會出現問題。將上面的代碼改寫一下：

 public class GenericTest {
    public static void demo1() {
        List list = new ArrayList();
        list.add("abc");
        list.add(123);
        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            String s = (String) o;
            System.out.println(s);
        }
     }
     public static void main(String[] args) {
        GenericTest.demo1();
      }
}

進行編譯：

編譯報錯

在文件名前加上-Xlint:unchecked，再次編譯：

再次編譯成功

此時編譯是成功的，因為泛型只是進行類型安全檢查，這里相當于忽略類型安全檢查。
再把上面的代碼改成使用泛型，并且只向數組中添加泛型類型的元素，然后遍歷、打印輸出：

public class GenericTest {
    public static void demo1() {
        List<String> list = new ArrayList<String>();
        list.add("abc");
        list.add("def");
        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            String s = (String) o;
            System.out.println(s);
        }
    }
   public static void main(String[] args) {
        GenericTest.demo1();
    }
}

再編譯：

編譯

就不會出現類型安全警告了。
需要注意的是，泛型是提供給javac編譯器使用的，它用于限定集合的輸入類型，讓編譯器在源代碼級別上，阻止向集合輸入非法數據的行為。但編譯器編譯完帶泛型的Java程序后，生成的class文件將不會含有泛型信息，使程序運行效率不受影響，這個過程稱之為“擦除”。
打開剛才編譯生成的class文件就會發現有這么一行 ：

class文件代碼

這一行關于數組的代碼中并沒有出現泛型信息，因為它在Java程序編譯完成后被擦除了。
實際上泛型對于List類、Set類和Map類都是生效的，這里只演示一種情況，其余幾種情況不再贅述。

編寫通用Java程序

先舉個例子，現在有兩個數組，一個數組的元素全部為int型，另一個則全部為String型，如果需要對兩個數組分別進行交換首尾元素位置的操作，最簡單方法就是寫兩個方法對兩個數組分別進行操作：

@Test
public void demo2(){//這個方法傳遞數組引用地址，因此不需要返回值，下面的方法同理
    int[] arr1 = new int[]{1, 2, 3, 4, 5};
    changePosition1(arr1, 0, arr1.length - 1); 
    System.out.println(Arrays.toString(arr1));
}
public void changePosition1(int[] arr, int index1, int index2){
    int temp = arr[index1];
    arr[index1] = arr[index2];
    arr[index2] = temp; 
}
@Test
public void demo3(){
    String[] arr2 = new String[]{"aaa", "bbb", "ccc", "ddd", "eee"};
    changePosition2(arr2, 0, arr2.length - 1);
    System.out.println(Arrays.toString(arr2));
}
public void changePosition2(String[] arr, int index1, int index2){
    String temp = arr[index1];
    arr[index1] = arr[index2];
    arr[index2] = temp;
}

再用JUnit進行單體測試：

demo2() 運行效果

demo3()運行效果

兩個方法都正確的。
但如果再加一個元素全部為double型的數組，仍然進行同樣的操作要怎么做呢？當然可以再寫一個類似的方法，修改一下代碼就行，但這樣會使代碼變得冗長，并且降低程序的運行效率，這個時候就可以用到泛型。原理很簡單，由于這兩個方法的實現中只是數據類型不同，就可以用泛型類型代替int型和String型甚至其它的數據類型，從而寫成一個對任何數據類型都通用的方法。
定義泛型方法時，必須在方法的返回值之前進行泛型類型聲明，語法為：

權限修飾符 <泛型類型> 返回值類型 方法名(參數列表){}

將上面的兩個方法利用泛型合并成一個方法，代碼為：

@Test
public void demo4(){
    Integer[] arr1 = new Integer[]{1, 2, 3, 4, 5};//泛型類型必須為對象類型而不能為原始類型
    changePosition(arr1, 0, arr1.length - 1);
    System.out.println(Arrays.toString(arr1));
    String[] arr2 = new String[] {"aaa", "bbb", "ccc", "ddd", "eee"};
    changePosition(arr2, 0, arr2.length - 1);
    System.out.println(Arrays.toString(arr2));
}
public <T> void changePosition(T[] arr, int index1, int index2){//這里的T即為泛型類型，參數列表中的數組類型也要修改
    T temp = arr[index1];
    arr[index1] = arr[index2];
    arr[index2] = temp;
}

用JUnit進行單體測試：

demo4()運行效果

結果仍然正確。
定義泛型的方法只對當前方法有效，也可以對類使用泛型。如果對一個類使用泛型，那么這個類中的所有方法都可以使用泛型。定義泛型的類語法為：

權限修飾符 class 類型<泛型類型>{}

還是用剛才的例子，這次用定義泛型類的方法完成交換元素位置的操作。首先要定義一個泛型類，并在類中定義具體的方法實現：

public class GenericUtils<T>{//這里的T為泛型類型
    public void changePosition(T[] arr, int index1, int index2){
        T temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = temp;
    }
}

再創建這個泛型類的數組對象，并調用類中的方法：

@Test
public void demo5(){
    GenericUtils<Integer> genericUtils1 = new GenericUtils<Integer>();
    GenericUtils<String> genericUtils2 = new GenericUtils<String>();
    Integer[] arr1 = new Integer[] {1, 2, 3, 4, 5};
    genericUtils1.changePosition(arr1, 0, arr1.length - 1);
    System.out.println(Arrays.toString(arr1));
    String[] arr2 = new String[] {"aaa", "bbb", "ccc", "ddd", "eee"};
    genericUtils2.changePosition(arr2, 0, arr2.length - 1);
    System.out.println(Arrays.toString(arr2));
}

用JUnit進行單體測試：

demo5()運行效果

結果依然是正確的。
需要注意的是，泛型的類不對類中的static方法生效，static方法必須重新定義泛型。另外，雖然泛型類型可以使用任意大寫字母，但建議使用有意義的字母，一般使用T、E、K、V，其中T對應Template（模板），E對應Element（元素），K對應Key（鍵），V對應Vaule（值）。