泛型在java中有很重要的地位，在面向?qū)ο缶幊碳案鞣N設(shè)計模式中有非常廣泛的應(yīng)用。
泛型是相關(guān)語言特性的集合，它允許類或方法對各種類型的對象進(jìn)行操作，同時提供編譯時類型安全性檢查
泛型在Java集合框架中被廣泛使用,我們不使用泛型,那么代碼將會是這樣:
List doubleList = new LinkedList();doubleList.add(3.5D);Double d = (Double) doubleList.iterator().next(); //類型強(qiáng)制轉(zhuǎn)換
doubleList中存儲一個Double類型的值, 但是List并不能阻止我們往里面再添加一個String類型
比如:doubleList.add (“ Hello world ”);
最后一行的(Double)強(qiáng)制轉(zhuǎn)換操作符將導(dǎo)致在遇到非 Double 對象時拋出 ClassCastException
因為直到運行時才檢測到類型安全性的缺失，所以開發(fā)人員可能不會意識到這個問題，將其留給客戶機(jī)(而不是編譯器)來發(fā)現(xiàn)。泛型允許開發(fā)人員將List標(biāo)記為只包含 Double 對象，從而幫助編譯器提醒開發(fā)人員在列表中存儲非 Double 類型的對象的問題,在編譯和開發(fā)期間,就把問題解決掉
我們可以這樣改造上面的代碼:
List<Double> doubleList = new LinkedList<Double>();doubleList.add(3.5D);Double d = doubleList.iterator().next();
這時 我們再添加String類型的參數(shù) 會提示需要的類型不符合需求.
泛型是通過類型參數(shù)引入一組類型的類或接口.
類型參數(shù):是一對尖括號之間以逗號分隔的類型參數(shù)名列表。
一提到參數(shù)，最熟悉的就是定義方法時有形參，然后調(diào)用此方法時傳遞實參。那么參數(shù)化類型怎么理解呢？顧名思義，就是將類型由原來的具體的類型參數(shù)化，類似于方法中的變量參數(shù)，此時類型也定義成參數(shù)形式（可以稱之為類型形參），然后在使用/調(diào)用時傳入具體的類型（類型實參）。
泛型的本質(zhì)是為了參數(shù)化類型（在不創(chuàng)建新的類型的情況下，通過泛型指定的不同類型來控制形參具體限制的類型）。也就是說在泛型使用過程中，操作的數(shù)據(jù)類型被指定為一個參數(shù)，這種參數(shù)類型可以用在類、接口和方法中，分別被稱為泛型類、泛型接口、泛型方法。
泛型類型遵循以下語法:
class identifier<formalTypeParameterList>{ }interface identifier<formalTypeParameterList>{ }interface Map<K,V> {//多個用逗號分隔}Java 編程約定要求類型參數(shù)名稱為單個大寫字母，例如 E 表示元素，K 表示鍵，V 表示值，T 表示類型。避免使用像A,B,C這樣沒有意義的名稱。
List < E > 表示一個元素列表，但是 List < B > 的意思是什么呢？
泛型的類型參數(shù)可以被替換為實際的類型參數(shù)(類型名稱)。例如，List < String > 是一個參數(shù)化類型，其中 String 是替換類型參數(shù) E 的實際類型參數(shù)。
類型參數(shù): 類型參數(shù) 傳遞給 類型參數(shù)
class Container<E> { Set<E> elements; //E傳給E}具體類:傳遞具體的類
例: List < Student > , Student為具體類 傳給E
參數(shù)化類:傳遞具體的參數(shù)化類
例: Set < List < Shape > >, List< Shape > 為具體的參數(shù)化類 傳給E
數(shù)組類型: 傳遞數(shù)組
例: Map < String, String[] >, String傳給K String[]傳給V
通配符: 使用問號(?)傳遞
例: Class < ? > , ? 傳給T
泛型的聲明涉及到指定形式類型參數(shù)列表，并在整個實現(xiàn)過程中訪問這些類型參數(shù)。使用泛型時需要在實例化泛型時將實際類型參數(shù)傳遞給類型參數(shù)
在本例子中,我們實現(xiàn)一個簡易的容器Container,該容器類型存儲相應(yīng)參數(shù)類型的對象,使其能夠存儲各種類型
class Container<E> //也可以使用實際類型的參數(shù){ private E[] elements; private int index; Container(int size) { elements = (E[]) new Object[size]; //本例中我們傳入的是String,將Object[]轉(zhuǎn)化為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 為無界類型參數(shù),通俗的講就是什么類型都可以,可以將任何實際的類型參數(shù)傳遞給 E
. 例如，可以指定 Container < Student > 、 Container < Employee > 或 Container < Person >
但是有時你想限制類型,比如你想 < E > 只接受 Employee 及其子類
class Employees<E extends Employee>
此時傳入的E 必須為 Employee子類, new Employees< String > 是無效的.
當(dāng)然我們還可以為一個類指定多個類型 使用&分隔 :
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可以按照自然順序進(jìn)行比較Comparable 接口聲明為泛型類型，只有一個名為 t 的類型參數(shù)。這個接口提供了一個 int compareTo (t o)方法，該方法將當(dāng)前對象與參數(shù)(類型為 t)進(jìn)行比較，當(dāng)該對象小于、等于或大于指定對象時返回負(fù)整數(shù)、零或正整數(shù)。*/{ 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)); }}假設(shè)你想要打印出一個對象列表
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 ()方法，防止類型安全的這種沖突。然而，這樣做并不是很有用。實際上編譯器已經(jīng)報出錯誤了,它告訴我們不能將字符串列表轉(zhuǎn)換為對象列表
為什么會報這個錯呢? 這和泛型的基本規(guī)則有關(guān):
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)的子類
根據(jù)這個規(guī)則，盡管 String 和 Integer 是 java.lang.Object 的子類,但是List < string > 和 List < integer > 是 List < Object > 的子類就不對了.
為什么我們有這個規(guī)則？因為泛型的設(shè)計是為了在編譯時捕獲類型安全違規(guī)行為。如果沒有泛型,我們可能會發(fā)生線上事故,因為程序拋出了 ClassCastException 并崩潰了！
作為演示，我們假設(shè) List < string > 是 List < object > 的子類型。如果這是真的，你可能會得到以下代碼:
List<String> directions = new ArrayList<String>();List<Object> objects = directions;objects.add(new Integer());String s = objects.get(0);
將一個整數(shù)添加到對象列表中，這違反了類型安全。問題發(fā)生在最后一行，該行拋出 ClassCastException，因為無法將存儲的整數(shù)強(qiáng)制轉(zhuǎn)換為字符串。
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()); }}我使用了一個通配符(?)在參數(shù)列表和 printList ()的方法體中，因為此符號代表任何類型，所以將 List < string > 和 List < integer > 傳遞給此方法是合法的
假如你現(xiàn)在有一個業(yè)務(wù)邏輯需要你將一個List 復(fù)制到另外一個List,要傳遞任意類型的源和目標(biāo)，需要使用通配符作為類型占位符
你可能會這樣寫:
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));}這時編譯器又又又報錯了
< ？ >意味著任何類型的對象都可以是列表的元素類型，并且源元素和目標(biāo)元素類型可能是不兼容的
例:源列表是一個 Shape 的 List，而目標(biāo)列表是一個 String 的 List，并且允許復(fù)制，那么在嘗試檢索目標(biāo)列表的元素時將拋出 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 后跟類型名來為通配符提供一個下限。這些邊界限制了可以作為實際類型參數(shù)傳遞的類型。
在這個例子中，因為 String 是 final，這意味著它不能被繼承，所以只能傳遞 String 對象的源列表和 String 或 Object 對象的目標(biāo)列表，這個問題只是解決了一部分,怎么辦呢
泛型方法的語法規(guī)范:
<formalTypeParameterList> returnType method(param)
類型參數(shù)可以用作返回類型，也可以出現(xiàn)在參數(shù)列表中
此時我們重寫代碼解決這個問題:
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);//函數(shù)式編程,使用lambda表達(dá)式實現(xiàn)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);}此時我們?yōu)?src、 dest 和 filter 參數(shù)的類型都包含類型參數(shù) T。這意味著在方法調(diào)用期間必須傳遞相同的實際類型參數(shù)，編譯器自動通過調(diào)用來推斷這個參數(shù)的類型是什么
Java 編譯器包含類型推斷算法，用于在實例化泛型類、調(diào)用類的泛型構(gòu)造函數(shù)或調(diào)用泛型方法時識別實際的類型參數(shù)。
在 Java SE 7之前，在實例化泛型類時，必須為變量的泛型類型和構(gòu)造函數(shù)指定相同的實際類型參數(shù)。例子:
Map<String, Set<String>> marbles = new HashMap<String, Set<String>>();
此時,代碼顯得非?；靵y,為了消除這種混亂,Java SE 7修改了類型推斷算法，以便可以用空列表< >替換構(gòu)造函數(shù)的實際類型參數(shù)，前提是編譯器可以從實例化上下文中推斷類型參數(shù)。示例:
Map<String, Set<String>> marbles = new HashMap<>();//使用<>替換<String, Set<String>>
要在泛型類實例化期間利用類型推斷，必須指定<>:
Map<String, Set<String>> marbles = new HashMap();
編譯器生成一個“ unchecked conversion warning” ，因為 HashMap ()構(gòu)造函數(shù)引用了 java.util。指定 HashMap 原始類型，而不是 HashMap<String, Set< String >>。
泛型類和非泛型類都可以聲明泛型構(gòu)造函數(shù)，其中構(gòu)造函數(shù)具有形式類型參數(shù)列表。例如，你可以用泛型構(gòu)造函數(shù)聲明如下泛型類:
public class Box<E>{ public <T> Box(T t) { // ... }}此聲明使用形式類型參數(shù) E 指定泛型類 Box < E > 。它還指定了一個具有形式類型參數(shù) T 的泛型構(gòu)造函數(shù)
那么在構(gòu)造函數(shù)調(diào)用時是這樣的:
new Box<Marble>("Aggies");進(jìn)一步利用菱形運算符來消除構(gòu)造函數(shù)調(diào)用中的 Marble 實際類型參數(shù)，只要編譯器能夠從實例化上下文中推斷出這個類型參數(shù):
new Box<>("Aggies");我們現(xiàn)在已經(jīng)知道了 編譯器會通過類型推斷算法識別出我們使用的類型
那么對于我們之前,將一個list拷貝到另外一個List的例子,我們還可以繼續(xù)改造一下
//copy是靜態(tài)方法 我們可以使用class.methodName的方式調(diào)用它Demo.<Integer>copy(grades, failedGrades, grade -> grade <= 50);
對于實例方法，語法幾乎完全相同。
new Demo().<Integer>copy(grades, failedGrades, grade -> grade <= 50);
在泛型代碼內(nèi)部，無法獲得任何有關(guān)泛型參數(shù)類型的信息 —《Java 編程思想》
ArrayList< String > () 和 ArrayList< Integer > ()
很容易被認(rèn)為是不同的類型，但是下面的打印結(jié)果卻是 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]分別打印它們的參數(shù)類型，可以發(fā)現(xiàn)，無論指定的是 Integer 類型還是 String 類型，最后輸出結(jié)果都僅是一個 用作參數(shù)占位符的標(biāo)識符 [E] 而已.
這意味著，在使用泛型時，任何具體的類型信息，比如上例中的 Integer 或 String，在泛型內(nèi)部都是無法獲得的，也就是，被擦除了。唯一知道的，就只是正在使用著的對象。由于 ArrayList< String >() 和 ArrayList< Integer >() 都會被擦除成“原生態(tài)”（即 List）
如果指定了邊界，例如< T extends Integer>，類型參數(shù)會被擦除為邊界（Integer），如果未指定邊界，例如，類型參數(shù)會被擦除為 Object 。
在使用泛型時，可能會遇到堆污染，其中參數(shù)化類型的變量引用的對象不是該參數(shù)化類型(例如，如果原始類型與參數(shù)化類型混合)。在這種情況下，編譯器報告“unchecked warning” ，因為無法驗證涉及參數(shù)化類型的操作(如強(qiáng)制轉(zhuǎn)換或方法調(diào)用)的正確性
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 具有參數(shù)化類型 Set < string > 。當(dāng) s 引用的 Set 被分配給 ss 時，編譯器會生成一個未檢查的警告。它因為編譯器不能確定 s 引用 Set < string > 類型。結(jié)果就是堆污染
第二個未檢查的警告:由于泛型擦除,編譯器也不能確定變量 s 是指 Set < string > 還是 Set < integer > 類型,這時就會產(chǎn)生 unchecked warning ，自然就會發(fā)生 堆污染了
@SafeVarargs在JDK 7中引入，主要目的是處理可變長參數(shù)中的泛型，此注解告訴編譯器：在可變長參數(shù)中的泛型是類型安全的?？勺冮L參數(shù)是使用數(shù)組存儲的，而數(shù)組和泛型不能很好的混合使用
簡單的說，數(shù)組元素的數(shù)據(jù)類型在編譯和運行時都是確定的，而泛型的數(shù)據(jù)類型只有在運行時才能確定下來，因此當(dāng)把一個泛型存儲到數(shù)組中時，編譯器在編譯階段無法檢查數(shù)據(jù)類型是否匹配，因此會給出警告信息：存在可能的“堆污染”(heap pollution)，即如果泛型的真實數(shù)據(jù)類型無法和參數(shù)數(shù)組的類型匹配，會導(dǎo)致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進(jìn)行編譯，需要修改編譯參數(shù)，增加-Xlint:unchecked編譯選項。
有如下的警告信息：
$ javac -Xlint:unchecked SafeVarargsTest.javaSafeVarargsTest.java:18: 警告: [unchecked] 參數(shù)化 vararg 類型T的堆可能已受污染public static < T> void showArgs(T… array) {^其中, T是類型變量:
T擴(kuò)展已在方法 < T>showArgs(T…)中聲明的Object
但是顯然在這個示例中，可變參數(shù)的泛型是安全的，因此可以啟用@SafeVarargs注解消除這個警告信息。
@SafeVarargs注解只能用在參數(shù)長度可變的方法或構(gòu)造方法上，且方法必須聲明為static或final，否則會出現(xiàn)編譯錯誤。一個方法使用@SafeVarargs注解的前提是，開發(fā)人員必須確保這個方法的實現(xiàn)中對泛型類型參數(shù)的處理不會引發(fā)類型安全問題，否則可能導(dǎo)致運行時的類型轉(zhuǎn)換異常。下面給出一個“堆污染”的實例
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對象（類型已經(jīng)擦除），賦值給Object類型的對象是允許的（向上塑型），能夠編譯通過 String s = stringLists[0].get(0); // 運行時拋出ClassCastException！ }}運行UnsafeMethodTest的結(jié)果如下：
Exception in thread “main” java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
數(shù)組array和stringLists同時指向了參數(shù)數(shù)組，tmpList是一個包含兩個Integer對象的list對象。
完
