如何使用 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），如果未指定邊界，例如
堆污染( 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寶典
