Java的類型擦除式泛型詳解

Posted on by

Java選擇的泛型類型叫做類型擦除式泛型。什麼是類型擦除式泛型呢？就是Java語言中的泛型隻存在於程序源碼之中，在編譯後的字節碼文件裡，則全部泛型都會被替換為原來的原始類型（Raw Type），並且會在相應的地方插入強制轉型的代碼。

因此，對於運行期間的Java程序來說ArrayList< Integer>和ArrayList< String>其實是同一個類型。這也就是Java選擇的泛型類型叫做類型擦除式泛型的原因。

ArrayList<String> stringArrays =new ArrayList<>();
ArrayList<Integer> intArrays =new ArrayList<>();

System.out.println(stringArrays.getClass().getTypeName().equals(intArrays.getClass().getTypeName()));

很顯然 答案是 true，因為他們的類型都是java.util.ArrayList

一、類型擦除式泛型

Java為什麼采用這種泛型呢？其實在於如果使用C#類型的泛型的話，會導致新的的Java版本無法去兼容原始的Java版本，也就會違背“二進制兼容性”原則。

所謂“二進制兼容性”,指的就是在升級java的版本時，不必重新修改原來的程序代碼，既可使得程序在現在以至於未來的版本中能夠正常運行。

也是因為“二進制兼容性”原則，Java在1.4.2之前的版本都沒有支持過泛型，如果需要在1.5之後的版本突然引入泛型，就需要考慮讓以前的程序在新版本的虛擬機中還能正常運行。

其實，Java的設計者也可以考慮學習C#一般，平行地增加一套泛型版本的新類型，以前的版本保持不變就行瞭。但是Java的設計人員並沒有這麼做，而是選擇瞭把已有的不支持泛型的類型泛型化，不添加任何平行於已有類型的泛型版。

還是我們剛剛所講的例子，因為Java1.5之後把所有的類型泛型化，所以ArrayList< Integer>和ArrayList< String>全都被轉化為瞭ArrayList的子類。

將之前的代碼反序列化之後，我們能夠看出強制轉化的類型消失瞭，Java代碼變回瞭泛型出現之前的寫法。

public static void main(String[] var0) {
    ArrayList var1 = new ArrayList();
    ArrayList var2 = new ArrayList();
}

當然，元素訪問時插入瞭從Object到String的時候，則會強制轉型代碼。

泛型擦除之後：

HashMap var1 = new HashMap();
var1.put("A", "A");
System.out.println((String)var1.get("A"));

HashMap var2 = new HashMap();
var2.put(1, "A");
System.out.println((String)var2.get(1));

HashMap var3 = new HashMap();
var3.put("A", 1);
System.out.println(var3.get("A"));

也是因為類型擦除的問題,我們存入List的不同類型的對象都可以自然的轉換成Object類型，但是取出的時候都需要強制轉換，所以會出現拆箱裝箱的消耗、以及可能出現的數據類型轉換的錯誤。因此，在使用集合的時候推薦使用ArrayList< String>這種已經轉換完畢的形式。

ArrayList var1 = new ArrayList();
var1.add("aaaa");
var1.add(100);
var1.add('c');
var1.add(21.5F);

二、泛型可能出現的問題

1、類型轉換的問題

如果我們想實現一個方法，想要將不確定的List集合轉化為數組，那我們該怎麼做？因為泛型的類型可擦除，我們無法直接從List中取得參數化類型T，所以隻能從額外的參數中傳遞一個數組的泛型類型進去進行轉換。

//必須傳遞Class<T> otherType作為參數類型
public static <T> T[] convert(List<T> list ,Class<T> otherType){
    T[] array = (T[]) Array.newInstance(otherType,list.size());
    return array;
}
public static void main(String[] args) {
    List<String> list = new ArrayList<String>(){{
        add("A");
    }};
 
    String[] result =convert(list,String.class);
}

當然，也可以通過反射手段來獲取泛型類型。

Class clazz = list.getClass();
//getSuperclass()獲得該類的父類

System.out.println(clazz.getSuperclass()); //class java.util.ArrayList
//getGenericSuperclass()獲得帶有泛型的父類
//Type是 Java 編程語言中所有類型的公共高級接口。它們包括原始類型、參數化類型、數組類型、類型變量和基本類型。

Type type = clazz.getGenericSuperclass();
System.out.println(type); //java.util.ArrayList<java.lang.String>

//ParameterizedType參數化類型，即泛型
ParameterizedType p = (ParameterizedType) type;

//getActualTypeArguments獲取參數化類型的數組，泛型可能有多個
Class c = (Class) p.getActualTypeArguments()[0];
System.out.println(c); //class java.lang.String

String[] convert = convert(list, c);

2、泛型與重載的矛盾

public static  void method(List<String> list){
     
}
public static  void method(List<Integer> list){
}

便已無法通過：
'method(List<Integer>)' clashes with 'method(List<String>)'; both methods have same erasure

我們已知上面的代碼是無法通過編譯的，因為List中的參數被擦除瞭，變成瞭原始類型的List。

三、泛型的最佳實踐

經過之前的論述，大傢已經知道瞭Java泛型的一些基礎知識，以及在使用泛型的時候可能出現的問題。如果在使用泛型的時候可以遵循一些基本的原則，就能避免一些常見的問題。

在代碼中避免泛型類和原始類型的混用。比如List< String>和List不應該共同使用。這樣會產生一些編譯器警告和潛在的運行時異常。當需要利用JDK 5之前開發的遺留代碼，而不得不這麼做時，也盡可能的隔離相關的代碼。

  1. 在代碼中避免泛型類和原始類型的混用。比如List< String>和List不應該共同使用。這樣會產生一些編譯器警告和潛在的運行時異常。當需要利用JDK 5之前開發的遺留代碼，而不得不這麼做時，也盡可能的隔離相關的代碼。
  2. 在使用帶通配符的泛型類的時候，盡可能的明確通配符所代表的一組類型的概念。
  3. 泛型類最好不要同數組一塊使用。你隻能創建new List<?>[10]這樣的數組，無法創建new List[10]這樣的。這限制瞭數組的使用能力，而且會帶來很多費解的問題。因此，當需要類似數組的功能時候，使用集合類即可。
  4. 如果編譯器給出的警告信息，在其他地方很多時候可以忽略(可能是格式帶來的問題)，但是在泛型代碼中還是盡量解決問題。

到此這篇關於Java的類型擦除式泛型詳解的文章就介紹到這瞭,更多相關Java擦除式泛型內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：