如何使用 Java 泛型來避免 ClassCastException

泛型在java中有很重要的地位，在面向物件編程及各種設計模式中有非常廣泛的應用，

一句話解釋什么是泛型？

泛型是相關語言特性的集合，它允許類或方法對各種型別的物件進行操作，同時提供編譯時型別安全性檢查

引入泛型之前

泛型在Java集合框架中被廣泛使用,我們不使用泛型,那么代碼將會是這樣:

List doubleList = new LinkedList();
doubleList.add(3.5D);
Double d = (Double) doubleList.iterator().next(); //型別強制轉換

doubleList中存盤一個Double型別的值, 但是List并不能阻止我們往里面再添加一個String型別

比如:doubleList.add (“ Hello world ”);

最后一行的(Double)強制轉換運算子將導致在遇到非 Double 物件時拋出 ClassCastException

引入泛型之后

因為直到運行時才檢測到型別安全性的缺失，所以開發人員可能不會意識到這個問題，將其留給客戶機(而不是編譯器)來發現，泛型允許開發人員將List標記為只包含 Double 物件，從而幫助編譯器提醒開發人員在串列中存盤非 Double 型別的物件的問題,在編譯和開發期間,就把問題解決掉

我們可以這樣改造上面的代碼:

List<Double> doubleList = new LinkedList<Double>();
doubleList.add(3.5D);
Double d = doubleList.iterator().next();

這時我們再添加String型別的引數會提示需要的型別不符合需求.

深入探索泛型類

泛型的概念

泛型是通過型別引數引入一組型別的類或介面.

型別引數:是一對尖括號之間以逗號分隔的型別引數名串列，

一提到引數，最熟悉的就是定義方法時有形參，然后呼叫此方法時傳遞實參，那么引數化型別怎么理解呢？顧名思義，就是將型別由原來的具體的型別引數化，類似于方法中的變數引數，此時型別也定義成引數形式（可以稱之為型別形參），然后在使用/呼叫時傳入具體的型別（型別實參），

泛型的本質是為了引數化型別（在不創建新的型別的情況下，通過泛型指定的不同型別來控制形參具體限制的型別），也就是說在泛型使用程序中，操作的資料型別被指定為一個引數，這種引數型別可以用在類、介面和方法中，分別被稱為泛型類、泛型介面、泛型方法，

泛型型別遵循語法

泛型型別遵循以下語法:

class identifier<formalTypeParameterList>{
  
}

interface identifier<formalTypeParameterList>{
 
}

interface Map<K,V> {//多個用逗號分隔
}

型別引數命名原則

Java 編程約定要求型別引數名稱為單個大寫字母，例如 E 表示元素，K 表示鍵，V 表示值，T 表示型別，避免使用像A,B,C這樣沒有意義的名稱，

List < E > 表示一個元素串列，但是 List < B > 的意思是什么呢？

實際型別引數替換型別引數

泛型的型別引數可以被替換為實際的型別引數(型別名稱)，例如，List < String > 是一個引數化型別，其中 String 是替換型別引數 E 的實際型別引數，

JAVA支持的實際型別的引數有哪些

型別引數: 型別引數傳遞給型別引數

class Container<E> { 
Set<E> elements; //E傳給E
}

具體類:傳遞具體的類

例: List < Student > , Student為具體類傳給E

引數化類:傳遞具體的引數化類

例: Set < List < Shape > >, List< Shape > 為具體的引數化類傳給E

陣列型別: 傳遞陣列

例: Map < String, String[] >, String傳給K String[]傳給V

通配符: 使用問號(?)傳遞

例: Class < ? > , ? 傳給T

宣告和使用泛型

泛型的宣告涉及到指定形式型別引數串列，并在整個實作程序中訪問這些型別引數，使用泛型時需要在實體化泛型時將實際型別引數傳遞給型別引數

定義泛型的例子

在本例子中,我們實作一個簡易的容器Container,該容器型別存盤相應引數型別的物件,使其能夠存盤各種型別

class Container<E>  //也可以使用實際型別的引數
{
   private E[] elements;
   private int index;
   Container(int size)
   {
      elements = (E[]) new Object[size];
      //本例中我們傳入的是String,將Object[]轉化為String[]回傳
      index = 0;
   }
   void add(E element)
   {
      elements[index++] = element;
   }
   E get(int index)
   {
      return elements[index];
   }
   int size()
   {
      return index;
   }
}
public class GenDemo
{
 
   public static void main(String[] args)
   {
      Container<String> con = new Container<String>(5);//使用String傳給E,指定E為String型別的
      con.add("North");
      con.add("South");
      con.add("East");
      con.add("West");
      for (int i = 0; i < con.size(); i++)
         System.out.println(con.get(i));
   }
}

指定型別引數的泛型

Container < E > 中的 E 為無界型別引數,通俗的講就是什么型別都可以,可以將任何實際的型別引數傳遞給 E
. 例如，可以指定 Container < Student > 、 Container < Employee > 或 Container < Person >

通過指定上限來限制傳入的類

但是有時你想限制型別,比如你想 < E > 只接受 Employee 及其子類

class Employees<E extends Employee>

此時傳入的E 必須為 Employee子類, new Employees< String > 是無效的.

指定多個型別限制

當然我們還可以為一個類指定多個型別使用&分隔 :

abstract class Employee
{
   private BigDecimal hourlySalary;
   private String name;
   Employee(String name, BigDecimal hourlySalary)
   {
      this.name = name;
      this.hourlySalary = hourlySalary;
   }
   public BigDecimal getHourlySalary()
   {
      return hourlySalary;
   }
   public String getName()
   {
      return name;
   }
   public String toString()
   {
      return name + ": " + hourlySalary.toString();
   }
}
class Accountant extends Employee implements Comparable<Accountant>
/*
Comparable < Accountant > 表明Accountant可以按照自然順序進行比較
Comparable 介面宣告為泛型型別，只有一個名為 t 的型別引數，
這個介面提供了一個 int compareTo (t o)方法，該方法將當前物件與引數(型別為 t)進行比較，
當該物件小于、等于或大于指定物件時回傳負整數、零或正整數，
*/

{
   Accountant(String name, BigDecimal hourlySalary)
   {
      super(name, hourlySalary);
   }
   public int compareTo(Accountant acct)
   {
      return getHourlySalary().compareTo(acct.getHourlySalary());
   }
}

class SortedEmployees<E extends Employee & Comparable<E>> 

//第一個必須為class 之后的必須為interface
{
   private E[] employees;
   private int index;
   @SuppressWarnings("unchecked")
   SortedEmployees(int size)
   {
      employees = (E[]) new Employee[size];
      int index = 0;
   }
   void add(E emp)
   {
      employees[index++] = emp;
      Arrays.sort(employees, 0, index);
   }
   E get(int index)
   {
      return employees[index];
   }
   int size()
   {
      return index;
   }
}
public class GenDemo
{
   public static void main(String[] args)
   {
      SortedEmployees<Accountant> se = new SortedEmployees<Accountant>(10);
      se.add(new Accountant("John Doe", new BigDecimal("35.40")));
      se.add(new Accountant("George Smith", new BigDecimal("15.20")));
      se.add(new Accountant("Jane Jones", new BigDecimal("25.60")));
      for (int i = 0; i < se.size(); i++)
         System.out.println(se.get(i));
   }
}

下界和泛型引數

假設你想要列印出一個物件串列

class Scratch_12{
    public static void main(String[] args) {
        {
            List<String> directions = new ArrayList();
            directions.add("north");
            directions.add("south");
            directions.add("east");
            directions.add("west");
            printList(directions);
            List<Integer> grades = new ArrayList();
            grades.add(new Integer(98));
            grades.add(new Integer(63));
            grades.add(new Integer(87));
            printList(grades);
        }

    }
    static void printList(List<Object> list)
    {
        Iterator<Object> iter = list.iterator();
        while (iter.hasNext())
            System.out.println(iter.next());
    }
}

這個例子看似是合乎邏輯的,我們想通過將 List < object > 型別的物件傳遞給 printList ()方法，防止型別安全的這種沖突，然而，這樣做并不是很有用，實際上編譯器已經報出錯誤了,它告訴我們不能將字串串列轉換為物件串列

為什么會報這個錯呢? 這和泛型的基本規則有關:

For a given subtype x of type y, and given G as a raw type declaration, G< x > is not a subtype of G < y >.
給定一個x類, x是y的子類, G作為原始型別宣告,G(x)不是G(y)的子類

根據這個規則，盡管 String 和 Integer 是 java.lang.Object 的子類,但是List < string > 和 List < integer > 是 List < Object > 的子類就不對了.

為什么我們有這個規則？因為泛型的設計是為了在編譯時捕獲型別安全違規行為，如果沒有泛型,我們可能會發生線上事故,因為程式拋出了 ClassCastException 并崩潰了！

作為演示，我們假設 List < string > 是 List < object > 的子型別，如果這是真的，你可能會得到以下代碼:

List<String> directions = new ArrayList<String>();
List<Object> objects = directions;
objects.add(new Integer());
String s = objects.get(0);

將一個整數添加到物件串列中，這違反了型別安全，問題發生在最后一行，該行拋出 ClassCastException，因為無法將存盤的整數強制轉換為字串，

使用通配符來解決問題

class Scratch_13{
    public static void main(String[] args) {
                List<String> directions = new ArrayList<String>();
                directions.add("north");
                directions.add("south");
                directions.add("east");
                directions.add("west");
                printList(directions);
                List<Integer> grades = new ArrayList<Integer>();
                grades.add(Integer.valueOf(98));
                grades.add(Integer.valueOf(63));
                grades.add(Integer.valueOf(87));
                printList(grades);
            }
                static void printList (List < ? > list)
                {
                    Iterator<?> iter = list.iterator();
                    while (iter.hasNext())
                        System.out.println(iter.next());
                }

}

我使用了一個通配符(?)在引數串列和 printList ()的方法體中，因為此符號代表任何型別，所以將 List < string > 和 List < integer > 傳遞給此方法是合法的

深入探索泛型方法

假如你現在有一個業務邏輯需要你將一個List 復制到另外一個List,要傳遞任意型別的源和目標，需要使用通配符作為型別占位符
你可能會這樣寫:

void copy(List<?> src, List<?> dest, Filter filter)
{
   for (int i = 0; i < src.size(); i++)
      if (filter.accept(src.get(i)))
         dest.add(src.get(i));
}

這時編譯器又又又報錯了

< ？ >意味著任何型別的物件都可以是串列的元素型別，并且源元素和目標元素型別可能是不兼容的

例:源串列是一個 Shape 的 List，而目標串列是一個 String 的 List，并且允許復制，那么在嘗試檢索目標串列的元素時將拋出 ClassCastException

指定型別上下界

void copy(List<? extends String> src, List<? super String> dest, Filter filter)
{
   for (int i = 0; i < src.size(); i++)
      if (filter.accept(src.get(i)))
         dest.add(src.get(i));
}

通過指定 extends 后跟型別名稱，可以為通配符提供一個上限，類似地，可以通過指定 super 后跟型別名來為通配符提供一個下限，這些邊界限制了可以作為實際型別引數傳遞的型別，

在這個例子中，因為 String 是 final，這意味著它不能被繼承，所以只能傳遞 String 物件的源串列和 String 或 Object 物件的目標串列，這個問題只是解決了一部分,怎么辦呢

使用泛型方法完全解決這個問題

泛型方法的語法規范:

<formalTypeParameterList> returnType method(param)

型別引數可以用作回傳型別，也可以出現在引數串列中

此時我們重寫代碼解決這個問題:

public class Demo
{
   public static void main(String[] args)
   {
      List<Integer> grades = new ArrayList<Integer>();
      Integer[] gradeValues = 
      {
         Integer.valueOf(96),
         Integer.valueOf(95),
         Integer.valueOf(27),
         Integer.valueOf(100),
         Integer.valueOf(43),
         Integer.valueOf(68)
      };
      
      for (int i = 0; i < gradeValues.length; i++){
        grades.add(gradeValues[i]);
      }
        
         
      List<Integer> failedGrades = new ArrayList<Integer>();
      
      copy(grades, failedGrades, grade -> grade <= 50);//函式式編程,使用lambda運算式實作Filter<T>此時T為Integer型別
                                 
      for (int i = 0; i < failedGrades.size(); i++){
          System.out.println(failedGrades.get(i));
      }
         
   }
   
   static <T> void copy(List<T> src, List<T> dest, Filter<T> filter)
   {
      for (int i = 0; i < src.size(); i++)
         if (filter.accept(src.get(i)))
            dest.add(src.get(i));
   }
}
interface Filter<T>
{
   boolean accept(T o);
}

此時我們為 src、 dest 和 filter 引數的型別都包含型別引數 T，這意味著在方法呼叫期間必須傳遞相同的實際型別引數，編譯器自動通過呼叫來推斷這個引數的型別是什么

泛型和型別推斷

Java 編譯器包含型別推斷演算法，用于在實體化泛型類、呼叫類的泛型建構式或呼叫泛型方法時識別實際的型別引數，

泛型類實體化

在 Java SE 7之前，在實體化泛型類時，必須為變數的泛型型別和建構式指定相同的實際型別引數，例子:

Map<String, Set<String>> marbles = new HashMap<String, Set<String>>();

此時,代碼顯得非常混亂,為了消除這種混亂,Java SE 7修改了型別推斷演算法，以便可以用空串列< >替換建構式的實際型別引數，前提是編譯器可以從實體化背景關系中推斷型別引數，示例:

Map<String, Set<String>> marbles = new HashMap<>();//使用<>替換<String, Set<String>>

要在泛型類實體化期間利用型別推斷，必須指定<>:

Map<String, Set<String>> marbles = new HashMap();

編譯器生成一個“ unchecked conversion warning” ，因為 HashMap ()建構式參考了 java.util，指定 HashMap 原始型別，而不是 HashMap<String, Set< String >>，

泛型建構式

泛型類和非泛型類都可以宣告泛型建構式，其中建構式具有形式型別引數串列，例如，你可以用泛型建構式宣告如下泛型類:

public class Box<E>
{
   public <T> Box(T t) 
   {
      // ...
   }
}

此宣告使用形式型別引數 E 指定泛型類 Box < E > ，它還指定了一個具有形式型別引數 T 的泛型建構式

那么在建構式呼叫時是這樣的:

new Box<Marble>("Aggies");

進一步利用菱形運算子來消除建構式呼叫中的 Marble 實際型別引數，只要編譯器能夠從實體化背景關系中推斷出這個型別引數:

new Box<>("Aggies");

泛型方法呼叫

我們現在已經知道了編譯器會通過型別推斷演算法識別出我們使用的型別
那么對于我們之前,將一個list拷貝到另外一個List的例子,我們還可以繼續改造一下

//copy是靜態方法 我們可以使用class.methodName的方式呼叫它
Demo.<Integer>copy(grades, failedGrades, grade -> grade <= 50);

對于實體方法，語法幾乎完全相同，

new Demo().<Integer>copy(grades, failedGrades, grade -> grade <= 50);

型別擦除

在泛型代碼內部，無法獲得任何有關泛型引數型別的資訊 —《Java 編程思想》

舉例說明

ArrayList< String > () 和 ArrayList< Integer > ()

很容易被認為是不同的型別，但是下面的列印結果卻是 true

public class ErasedType {

    public static void main(String[] args) {

        Class c1 = new ArrayList<String>().getClass();
        Class c2 = new ArrayList<Integer>().getClass();

        // output：true
        System.out.println(c1 == c2);
    }
}

System.out.println(Arrays.toString(c1.getTypeParameters()));
// output：[E]
System.out.println(Arrays.toString(c2.getTypeParameters()));
// output：[E]

分別列印它們的引數型別，可以發現，無論指定的是 Integer 型別還是 String 型別，最后輸出結果都僅是一個用作引數占位符的識別符號 [E] 而已.

這意味著，在使用泛型時，任何具體的型別資訊，比如上例中的 Integer 或 String，在泛型內部都是無法獲得的，也就是，被擦除了，唯一知道的，就只是正在使用著的物件，由于 ArrayList< String >() 和 ArrayList< Integer >() 都會被擦除成“原生態”（即 List）

如果指定了邊界，例如< T extends Integer>，型別引數會被擦除為邊界（Integer），如果未指定邊界，例如，型別引數會被擦除為 Object ，

堆污染( heap pollution)

在使用泛型時，可能會遇到堆污染，其中引數化型別的變數參考的物件不是該引數化型別(例如，如果原始型別與引數化型別混合)，在這種情況下，編譯器報告“unchecked warning” ，因為無法驗證涉及引數化型別的操作(如強制轉換或方法呼叫)的正確性

堆污染示例

  import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class Scratch_15
{
   public static void main(String[] args)
   {
      Set s = new TreeSet<Integer>();
      Set<String> ss = s;            // unchecked warning Unchecked assignment: 'java.util.Set' to 'java.util.Set<java.lang.String>' 
      s.add(42);    // unchecked warning Unchecked call to 'add(E)' as a member of raw type 'java.util.Set' 
      Iterator<String> iter = ss.iterator();
      while (iter.hasNext())
      {
         String str = iter.next();   //throw ClassCastException 
         System.out.println(str);
      }
   }
}
/*

    Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
        at Scratch_15.main(scratch_15.java:17)
 */

第一個未檢查的警告:變數 ss 具有引數化型別 Set < string > ，當 s 參考的 Set 被分配給 ss 時，編譯器會生成一個未檢查的警告，它因為編譯器不能確定 s 參考 Set < string > 型別，結果就是堆污染
第二個未檢查的警告:由于泛型擦除,編譯器也不能確定變數 s 是指 Set < string > 還是 Set < integer > 型別,這時就會產生 unchecked warning ，自然就會發生堆污染了

@SafeVarargs的用法

@SafeVarargs在JDK 7中引入，主要目的是處理可變長引數中的泛型，此注解告訴編譯器：在可變長引數中的泛型是型別安全的，可變長引數是使用陣列存盤的，而陣列和泛型不能很好的混合使用
簡單的說，陣列元素的資料型別在編譯和運行時都是確定的，而泛型的資料型別只有在運行時才能確定下來，因此當把一個泛型存盤到陣列中時，編譯器在編譯階段無法檢查資料型別是否匹配，因此會給出警告資訊：存在可能的“堆污染”(heap pollution)，即如果泛型的真實資料型別無法和引數陣列的型別匹配，會導致ClassCastException例外，

import java.util.ArrayList;

public class SafeVarargsTest {
    public static void main(String[] args) {
        ArrayList<Integer> a1 = new ArrayList<>();
        a1.add(new Integer(1));
        a1.add(2);
        showArgs(a1, 12);
    }

    //@SafeVarargs
    public static <T> void showArgs(T... array) {
        for (T arg : array) {
            System.out.println(arg.getClass().getName() + ":" + arg);
        }
    }

}

如果使用IDE進行編譯，需要修改編譯引數，增加-Xlint:unchecked編譯選項，
有如下的警告資訊：

$ javac -Xlint:unchecked SafeVarargsTest.java
SafeVarargsTest.java:18: 警告: [unchecked] 引數化 vararg 型別T的堆可能已受污染
public static < T> void showArgs(T… array) {
^

其中, T是型別變數:
T擴展已在方法 < T>showArgs(T…)中宣告的Object

但是顯然在這個示例中，可變引數的泛型是安全的，因此可以啟用@SafeVarargs注解消除這個警告資訊，

@SafeVarargs注解只能用在引數長度可變的方法或構造方法上，且方法必須宣告為static或final，否則會出現編譯錯誤，一個方法使用@SafeVarargs注解的前提是，開發人員必須確保這個方法的實作中對泛型型別引數的處理不會引發型別安全問題，否則可能導致運行時的型別轉換例外，下面給出一個“堆污染”的實體


import java.util.Arrays;
import java.util.List;

public class UnsafeMethodTest {

    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("one", "two");
        List<String> list2 = Arrays.asList("three","four");
        unsafeMethod(list1, list2);
    }

    @SafeVarargs  //并不安全
    static void unsafeMethod(List<String>... stringLists) {
        Object[] array = stringLists;
        List<Integer> tmpList = Arrays.asList(42, 56);
        array[0] = tmpList; // tmpList是一個List物件（型別已經擦除），賦值給Object型別的物件是允許的（向上塑型），能夠編譯通過
        String s = stringLists[0].get(0); // 運行時拋出ClassCastException！
    }
}

運行UnsafeMethodTest的結果如下：

Exception in thread “main” java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

陣列array和stringLists同時指向了引數陣列，tmpList是一個包含兩個Integer物件的list物件，

完

記得點贊關注@Java寶典

關注公眾號:java寶典

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/250449.html

標籤：Java

上一篇：Docker部署ElasticSearch集群

下一篇：MyBatis 查詢時屬性中一對多的問題（一條資料對應多條資料）

如何使用 Java 泛型來避免 ClassCastException

如何使用 Java 泛型來避免 ClassCastException

一句話解釋什么是泛型？

引入泛型之前

引入泛型之后

深入探索泛型類

泛型的概念

泛型型別遵循語法

型別引數命名原則

實際型別引數 替換 型別引數

JAVA支持的實際型別的引數有哪些

宣告和使用泛型

定義泛型的例子

指定型別引數的泛型

通過指定上限來限制傳入的類

指定多個型別限制

下界和泛型引數

使用通配符來解決問題

深入探索泛型方法

指定型別上下界

使用泛型方法完全解決這個問題

泛型和型別推斷

泛型類實體化

泛型建構式

泛型方法呼叫

型別擦除

舉例說明

堆污染( heap pollution)

堆污染示例

@SafeVarargs的用法

實際型別引數替換型別引數