泛型是什麽

一說到泛型，大夥肯定不會陌生，我們代碼裏面有很多類似這樣的語句：

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

ArrayList就是個泛型類，我們通過設定不同的類型，可以往集合裏面存儲不同類型的數據類型（而且只能存儲設定的數據類型，這是泛型的優勢之一）。“泛型”簡單的意思就是泛指的類型（參數化類型）。想象下這樣的場景：如果我們現在要寫一個容器類（支持數據增刪查詢的），我們寫了支持String類型的，後面還需要寫支持Integer類型的。然後呢？Doubel、Float、各種自定義類型？這樣重復代碼太多了，而且這些容器的算法都是一致的。我們可以通過泛指一種類型T,來代替我們之前需要的所有類型，把我們需要的類型作為參數傳遞到容器裏面，這樣我們算法只需要寫一套就可以適應所有的類型。最典型的的例子就是ArrayList了，這個集合我們無論傳遞什麽數據類型，它都能很好的工作。

class MyList{
    private Object[] elements=new Object[10];
    private int size;
    
    public void add(Object item) {
    	elements[size++]=item;
    }
    
    public Object get(int index) {
    	return elements[index];
    }
}

這個代碼靈活性很高，所有的類型都可以向上轉型為Object類，這樣我們就可以往裏面存儲各種類型的數據了。的確Java在泛型出現之前，也是這麽做的。但是這樣的有一個問題：如果集合裏面數據很多，某一個數據轉型出現錯誤，在編譯期是無法發現的。但是在運行期會發生java.lang.ClassCastException。例如：

MyList myList=new MyList();
myList.add("A");
myList.add(1);
System.out.println(myList.get(0));
System.out.println((String)myList.get(1));

我們在這個集合裏面存儲了多個類型（某些情況下容器可能會存儲多種類型的數據），如果數據量較多，轉型的時候難免會出現異常，而這些都是無法在編譯期得知的。而泛型一方面讓我們只能往集合中添加一種類型的數據，同時可以讓我們在編譯期就發現這些錯誤，避免運行時異常的發生，提升代碼的健壯性。

Java泛型介紹

下面我們來介紹Java泛型的相關內容，下面會介紹以下幾個方面：

• Java泛型類
• Java泛型方法
• Java泛型接口
• Java泛型擦除及其相關內容
• Java泛型通配符

Java泛型類

類結構是面向對象中最基本的元素，如果我們的類需要有很好的擴展性，那麽我們可以將其設置成泛型的。假設我們需要一個數據的包裝類，通過傳入不同類型的數據，可以存儲相應類型的數據。我們看看這個簡單的泛型類的設計：

class DataHolder<T>{
    T item;
    
    public void setData(T t) {
    	this.item=t;
    }
    
    public T getData() {
    	return this.item;
    }
}

泛型類定義時只需要在類名後面加上類型參數即可，當然你也可以添加多個參數，類似於<K,V>,<T,E,K>等。這樣我們就可以在類裏面使用定義的類型參數。
泛型類最常用的使用場景就是“元組”的使用。我們知道方法return返回值只能返回單個對象。如果我們定義一個泛型類，定義2個甚至3個類型參數，這樣我們return對象的時候，構建這樣一個“元組”數據，通過泛型傳入多個對象，這樣我們就可以一次性方法多個數據了。

Java泛型方法

前面我們介紹的泛型是作用於整個類的，現在我們來介紹泛型方法。泛型方法既可以存在於泛型類中，也可以存在於普通的類中。如果使用泛型方法可以解決問題，那麽應該盡量使用泛型方法。下面我們通過例子來看一下泛型方法的使用：

class DataHolder<T>{
    T item;
    
    public void setData(T t) {
    	this.item=t;
    }
    
    public T getData() {
    	return this.item;
    }
    
    /**
     * 泛型方法
     * @param e
     */
    public <E> void PrinterInfo(E e) {
    	System.out.println(e);
    }
}

我們來看運行結果：

1
AAAAA
8.88

從上面的例子中，我們看到我們是在一個泛型類裏面定義了一個泛型方法printInfo。通過傳入不同的數據類型，我們都可以打印出來。在這個方法裏面，我們定義了類型參數E。這個E和泛型類裏面的T兩者之間是沒有關系的。哪怕我們將泛型方法設置成這樣：

//註意這個T是一種全新的類型，可以與泛型類中聲明的T不是同一種類型。
public <T> void PrinterInfo(T e) {
    System.out.println(e);
}
//調用方法
DataHolder<String> dataHolder=new DataHolder<>();
dataHolder.PrinterInfo(1);
dataHolder.PrinterInfo("AAAAA");
dataHolder.PrinterInfo(8.88f);

這個泛型方法依然可以傳入Double、Float等類型的數據。泛型方法裏面的類型參數T和泛型類裏面的類型參數是不一樣的類型，從上面的調用方式，我們也可以看出，泛型方法printInfo不受我們DataHolder中泛型類型參數是String的影響。 我們來總結下泛型方法的幾個基本特征：

• public與返回值中間非常重要，可以理解為聲明此方法為泛型方法。
• 只有聲明了的方法才是泛型方法，泛型類中的使用了泛型的成員方法並不是泛型方法。
• 表明該方法將使用泛型類型T，此時才可以在方法中使用泛型類型T。
• 與泛型類的定義一樣，此處T可以隨便寫為任意標識，常見的如T、E、K、V等形式的參數常用於表示泛型。

Java泛型接口

Java泛型接口的定義和Java泛型類基本相同，下面是一個例子：

//定義一個泛型接口
public interface Generator<T> {
    public T next();
}

此處有兩點需要註意：

• 泛型接口未傳入泛型實參時，與泛型類的定義相同，在聲明類的時候，需將泛型的聲明也一起加到類中。例子如下：

/* 即：class DataHolder implements Generator<T>{
 * 如果不聲明泛型，如：class DataHolder implements Generator<T>，編譯器會報錯："Unknown class"
 */
class FruitGenerator<T> implements Generator<T>{
    @Override
    public T next() {
        return null;
    }
}

• 如果泛型接口傳入類型參數時，實現該泛型接口的實現類，則所有使用泛型的地方都要替換成傳入的實參類型。例子如下：

class DataHolder implements Generator<String>{
    @Override
    public String next() {
    	return null;
    }
}

從這個例子我們看到，實現類裏面的所有T的地方都需要實現為String。

Java泛型擦除及其相關內容

我們下面看一個例子：

Class<?> class1=new ArrayList<String>().getClass();
Class<?> class2=new ArrayList<Integer>().getClass();
System.out.println(class1);		//class java.util.ArrayList
System.out.println(class2);		//class java.util.ArrayList
System.out.println(class1.equals(class2));	//true

我們看輸出發現，class1和class2居然是同一個類型ArrayList，在運行時我們傳入的類型變量String和Integer都被丟掉了。Java語言泛型在設計的時候為了兼容原來的舊代碼，Java的泛型機制使用了“擦除”機制。我們來看一個更徹底的例子：

class Table {}
class Room {}
class House<Q> {}
class Particle<POSITION, MOMENTUM> {}
//調用代碼及輸出
List<Table> tableList = new ArrayList<Table>();
Map<Room, Table> maps = new HashMap<Room, Table>();
House<Room> house = new House<Room>();
Particle<Long, Double> particle = new Particle<Long, Double>();
System.out.println(Arrays.toString(tableList.getClass().getTypeParameters()));
System.out.println(Arrays.toString(maps.getClass().getTypeParameters()));
System.out.println(Arrays.toString(house.getClass().getTypeParameters()));
System.out.println(Arrays.toString(particle.getClass().getTypeParameters()));
/** 
[E]
[K, V]
[Q]
[POSITION, MOMENTUM]
 */

上面的代碼裏，我們想在運行時獲取類的類型參數，但是我們看到返回的都是“形參”。在運行期我們是獲取不到任何已經聲明的類型信息的。
註意：
編譯器雖然會在編譯過程中移除參數的類型信息，但是會保證類或方法內部參數類型的一致性。
泛型參數將會被擦除到它的第一個邊界（邊界可以有多個，重用 extends 關鍵字，通過它能給與參數類型添加一個邊界）。編譯器事實上會把類型參數替換為它的第一個邊界的類型。如果沒有指明邊界，那麽類型參數將被擦除到Object。下面的例子中，可以把泛型參數T當作HasF類型來使用。

public interface HasF {
    void f();
}

public class Manipulator<T extends HasF> {
    T obj;
    public T getObj() {
        return obj;
    }
    public void setObj(T obj) {
        this.obj = obj;
    }
}

extend關鍵字後後面的類型信息決定了泛型參數能保留的信息。Java類型擦除只會擦除到HasF類型。

Java泛型擦除的原理

我們通過例子來看一下，先看一個非泛型的版本：

// SimpleHolder.java
public class SimpleHolder {
    private Object obj;
    public Object getObj() {
        return obj;
    }
    public void setObj(Object obj) {
        this.obj = obj;
    }
    public static void main(String[] args) {
        SimpleHolder holder = new SimpleHolder();
        holder.setObj("Item");
        String s = (String) holder.getObj();
    }
}
// SimpleHolder.class
public class SimpleHolder {
  public SimpleHolder();
    Code:
       0: aload_0       
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return        

  public java.lang.Object getObj();
    Code:
       0: aload_0       
       1: getfield      #2                  // Field obj:Ljava/lang/Object;
       4: areturn       

  public void setObj(java.lang.Object);
    Code:
       0: aload_0       
       1: aload_1       
       2: putfield      #2                  // Field obj:Ljava/lang/Object;
       5: return        

  public static void main(java.lang.String[]);
    Code:
       0: new           #3                  // class SimpleHolder
       3: dup           
       4: invokespecial #4                  // Method "<init>":()V
       7: astore_1      
       8: aload_1       
       9: ldc           #5                  // String Item
      11: invokevirtual #6                  // Method setObj:(Ljava/lang/Object;)V
      14: aload_1       
      15: invokevirtual #7                  // Method getObj:()Ljava/lang/Object;
      18: checkcast     #8                  // class java/lang/String
      21: astore_2      
      22: return        
}

下面我們給出一個泛型的版本，從字節碼的角度來看看:

//GenericHolder.java
public class GenericHolder<T> {
    T obj;
    public T getObj() {
        return obj;
    }
    public void setObj(T obj) {
        this.obj = obj;
    }
    public static void main(String[] args) {
        GenericHolder<String> holder = new GenericHolder<>();
        holder.setObj("Item");
        String s = holder.getObj();
    }
}

//GenericHolder.class
public class GenericHolder<T> {
  T obj;

  public GenericHolder();
    Code:
       0: aload_0       
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return        

  public T getObj();
    Code:
       0: aload_0       
       1: getfield      #2                  // Field obj:Ljava/lang/Object;
       4: areturn       

  public void setObj(T);
    Code:
       0: aload_0       
       1: aload_1       
       2: putfield      #2                  // Field obj:Ljava/lang/Object;
       5: return        

  public static void main(java.lang.String[]);
    Code:
       0: new           #3                  // class GenericHolder
       3: dup           
       4: invokespecial #4                  // Method "<init>":()V
       7: astore_1      
       8: aload_1       
       9: ldc           #5                  // String Item
      11: invokevirtual #6                  // Method setObj:(Ljava/lang/Object;)V
      14: aload_1       
      15: invokevirtual #7                  // Method getObj:()Ljava/lang/Object;
      18: checkcast     #8                  // class java/lang/String
      21: astore_2      
      22: return        
}

在編譯過程中，類型變量的信息是能拿到的。所以，set方法在編譯器可以做類型檢查，非法類型不能通過編譯。但是對於get方法，由於擦除機制，運行時的實際引用類型為Object類型。為了“還原”返回結果的類型，編譯器在get之後添加了類型轉換。所以，在GenericHolder.class文件main方法主體第18行有一處類型轉換的邏輯。它是編譯器自動幫我們加進去的。
所以在泛型類對象讀取和寫入的位置為我們做了處理，為代碼添加約束。

Java泛型擦除的缺陷及補救措施

泛型類型不能顯式地運用在運行時類型的操作當中，例如：轉型、instanceof 和 new。因為在運行時，所有參數的類型信息都丟失了。類似下面的代碼都是無法通過編譯的：

public class Erased<T> {
    private final int SIZE = 100;
    public static void f(Object arg) {
        //編譯不通過
        if (arg instanceof T) {
        }
        //編譯不通過
        T var = new T();
        //編譯不通過
        T[] array = new T[SIZE];
        //編譯不通過
        T[] array = (T) new Object[SIZE];
    }
}

那我們有什麽辦法來補救呢？下面介紹幾種方法來一一解決上面出現的問題。

類型判斷問題

我們可以通過下面的代碼來解決泛型的類型信息由於擦除無法進行類型判斷的問題：

/**
 * 泛型類型判斷封裝類
 * @param <T>
 */
class GenericType<T>{
    Class<?> classType;
    
    public GenericType(Class<?> type) {
        classType=type;
    }
    
    public boolean isInstance(Object object) {
        return classType.isInstance(object);
    }
}

在main方法我們可以這樣調用：

GenericType<A> genericType=new GenericType<>(A.class);
System.out.println("------------");
System.out.println(genericType.isInstance(new A()));
System.out.println(genericType.isInstance(new B()));

我們通過記錄類型參數的Class對象，然後通過這個Class對象進行類型判斷。

創建類型實例

泛型代碼中不能new T()的原因有兩個，一是因為擦除，不能確定類型；而是無法確定T是否包含無參構造函數。
為了避免這兩個問題，我們使用顯式的工廠模式：

/**
 * 使用工廠方法來創建實例
 *
 * @param <T>
 */
interface Factory<T>{
    T create();
}

class Creater<T>{
    T instance;
    public <F extends Factory<T>> T newInstance(F f) {
    	instance=f.create();
    	return instance;
    }
}

class IntegerFactory implements Factory<Integer>{
    @Override
    public Integer create() {
    	Integer integer=new Integer(9);
    	return integer;
    }
}

我們通過工廠模式+泛型方法來創建實例對象，上面代碼中我們創建了一個IntegerFactory工廠，用來創建Integer實例，以後代碼有變動的話，我們可以添加新的工廠類型即可。
調用代碼如下：

Creater<Integer> creater=new Creater<>();
System.out.println(creater.newInstance(new IntegerFactory()));

創建泛型數組

一般不建議創建泛型數組。盡量使用ArrayList來代替泛型數組。但是在這裏還是給出一種創建泛型數組的方法。

public class GenericArrayWithTypeToken<T> {
    private T[] array;

    @SuppressWarnings("unchecked")
    public GenericArrayWithTypeToken(Class<T> type, int sz) {
        array = (T[]) Array.newInstance(type, sz);
    }

    public void put(int index, T item) {
        array[index] = item;
    }

    public T[] rep() {
        return array;
    }

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

這裏我們使用的還是傳參數類型，利用類型的newInstance方法創建實例的方式。

Java泛型的通配符

上界通配符<? extends T>

我們先來看一個例子：

class Fruit {}
class Apple extends Fruit {}

現在我們定義一個盤子類：

class Plate<T>{
    T item;
    public Plate(T t){
        item=t;
    }
    
    public void set(T t) {
        item=t;
    }
    
    public T get() {
        return item;
    }
}

下面，我們定義一個水果盤子，理論上水果盤子裏，當然可以存在蘋果

Plate<Fruit> p=new Plate<Apple>(new Apple());

你會發現這段代碼無法進行編譯。裝蘋果的盤子”無法轉換成“裝水果的盤子：

cannot convert from Plate<Apple> to Plate<Fruit>

從上面代碼我們知道，就算容器中的類型之間存在繼承關系，但是Plate和Plate兩個容器之間是不存在繼承關系的。 在這種情況下，Java就設計成Plate<? extend Fruit>來讓兩個容器之間存在繼承關系。我們上面的代碼就可以進行賦值了

Plate<? extends Fruit> p=new Plate<Apple>(new Apple());

Plate<? extend Fruit>是Plate< Fruit >和Plate< Apple >的基類。
我們通過一個更加詳細的例子來看一下上界的界限：

class Food{}

class Fruit extends Food {}
class Meat extends Food {}

class Apple extends Fruit {}
class Banana extends Fruit {}
class Pork extends Meat{}
class Beef extends Meat{}

class RedApple extends Apple {}
class GreenApple extends Apple {}

在上面這個類層次中，Plate<? extend Fruit>，覆蓋下面的藍色部分：

如果我們往盤子裏面添加數據，例如：

p.set(new Fruit());
p.set(new Apple());

你會發現無法往裏面設置數據，按道理說我們將泛型類型設置為? extend Fruit。按理說我們往裏面添加Fruit的子類應該是可以的。但是Java編譯器不允許這樣操作。<? extends Fruit>會使往盤子裏放東西的set()方法失效。但取東西get()方法還有效
原因是：
Java編譯期只知道容器裏面存放的是Fruit和它的派生類，具體是什麽類型不知道，可能是Fruit？可能是Apple？也可能是Banana，RedApple，GreenApple？編譯器在後面看到Plate< Apple >賦值以後，盤子裏面沒有標記為“蘋果”。只是標記了一個占位符“CAP#1”，來表示捕獲一個Fruit或者Fruit的派生類，具體是什麽類型不知道。所有調用代碼無論往容器裏面插入Apple或者Meat或者Fruit編譯器都不知道能不能和這個“CAP#1”匹配，所以這些操作都不允許。
但是上界通配符是允許讀取操作的。例如代碼：

Fruit fruit=p.get();
Object object=p.get();

這個我們很好理解，由於上界通配符設定容器中只能存放Fruit及其派生類，那麽獲取出來的我們都可以隱式的轉為其基類（或者Object基類）。所以上界描述符Extends適合頻繁讀取的場景。

下界通配符<? super T>

下界通配符的意思是容器中只能存放T及其T的基類類型的數據。我們還是以上面類層次的來看，<? super Fruit>覆蓋下面的紅色部分：

下界通配符<? super T>不影響往裏面存儲，但是讀取出來的數據只能是Object類型。
原因是：
下界通配符規定了元素最小的粒度，必須是T及其基類，那麽我往裏面存儲T及其派生類都是可以的，因為它都可以隱式的轉化為T類型。但是往外讀就不好控制了，裏面存儲的都是T及其基類，無法轉型為任何一種類型，只有Object基類才能裝下。

PECS原則

最後簡單介紹下Effective Java這本書裏面介紹的PECS原則。

• 上界<? extends T>不能往裏存，只能往外取，適合頻繁往外面讀取內容的場景。

• 下界<? super T>不影響往裏存，但往外取只能放在Object對象裏，適合經常往裏面插入數據的場景。

<?>無限通配符

無界通配符 意味著可以使用任何對象，因此使用它類似於使用原生類型。但它是有作用的，原生類型可以持有任何類型，而無界通配符修飾的容器持有的是某種具體的類型。舉個例子，在List類型的引用中，不能向其中添加Object, 而List類型的引用就可以添加Object類型的變量。
最後提醒一下的就是，List與List並不等同，List是List的子類。還有不能往List<?> list裏添加任意對象，除了null。

傳播一個喜大普奔的消息

騰訊雲年中大優惠，註冊即領500減350優惠卷，雲服務器最低2折，1核1G內存50G硬盤1年最低325元！戳此了解詳情！

鏈接：https://juejin.im/post/5b614848e51d45355d51f792

深入理解Java泛型