14. Java基礎之泛型
引用自:https://www.cnblogs.com/lwbqqyumidi/p/3837629.html , https://blog.csdn.net/s10461/article/details/53941091,https://blog.csdn.net/sunxianghuang/article/details/51982979
一. 泛型概念的提出(為什麽需要泛型)?
首先,我們看下下面這段簡短的代碼:
1 public class GenericTest { 2 3 public static void main(String[] args) { 4 List list = newView CodeArrayList(); 5 list.add("qqyumidi"); 6 list.add("corn"); 7 list.add(100); 8 9 for (int i = 0; i < list.size(); i++) { 10 String name = (String) list.get(i); // 1 11 System.out.println("name:" + name); 12 } 13 } 14 }
定義了一個List類型的集合,先向其中加入了兩個字符串類型的值,隨後加入一個Integer類型的值。這是完全允許的,因為此時list默認的類型為Object類型。在之後的循環中,由於忘記了之前在list中也加入了Integer類型的值或其他編碼原因,很容易出現類似於//1中的錯誤。因為編譯階段正常,而運行時會出現“java.lang.ClassCastException”異常。因此,導致此類錯誤編碼過程中不易發現。
在如上的編碼過程中,我們發現主要存在兩個問題:
1.當我們將一個對象放入集合中,集合不會記住此對象的類型,當再次從集合中取出此對象時,改對象的編譯類型變成了Object類型,但其運行時類型任然為其本身類型。
2.因此,//1處取出集合元素時需要人為的強制類型轉化到具體的目標類型,且很容易出現“java.lang.ClassCastException”異常。
那麽有沒有什麽辦法可以使集合能夠記住集合內元素各類型,且能夠達到只要編譯時不出現問題,運行時就不會出現“java.lang.ClassCastException”異常呢?答案就是使用泛型。
二.什麽是泛型?
泛型,即“參數化類型”。一提到參數,最熟悉的就是定義方法時有形參,然後調用此方法時傳遞實參。那麽參數化類型怎麽理解呢?顧名思義,就是將類型由原來的具體的類型參數化,類似於方法中的變量參數,此時類型也定義成參數形式(可以稱之為類型形參),然後在使用/調用時傳入具體的類型(類型實參)。
看著好像有點復雜,首先我們看下上面那個例子采用泛型的寫法。
1 public class GenericTest { 2 3 public static void main(String[] args) { 4 /* 5 List list = new ArrayList(); 6 list.add("qqyumidi"); 7 list.add("corn"); 8 list.add(100); 9 */ 10 11 List<String> list = new ArrayList<String>(); 12 list.add("qqyumidi"); 13 list.add("corn"); 14 //list.add(100); // 1 提示編譯錯誤 15 16 for (int i = 0; i < list.size(); i++) { 17 String name = list.get(i); // 2 18 System.out.println("name:" + name); 19 } 20 } 21 }View Code
采用泛型寫法後,在//1處想加入一個Integer類型的對象時會出現編譯錯誤,通過List<String>,直接限定了list集合中只能含有String類型的元素,從而在//2處無須進行強制類型轉換,因為此時,集合能夠記住元素的類型信息,編譯器已經能夠確認它是String類型了。
結合上面的泛型定義,我們知道在List<String>中,String是類型實參,也就是說,相應的List接口中肯定含有類型形參。且get()方法的返回結果也直接是此形參類型(也就是對應的傳入的類型實參)。下面就來看看List接口的的具體定義:
1 public interface List<E> extends Collection<E> { 2 3 int size(); 4 5 boolean isEmpty(); 6 7 boolean contains(Object o); 8 9 Iterator<E> iterator(); 10 11 Object[] toArray(); 12 13 <T> T[] toArray(T[] a); 14 15 boolean add(E e); 16 17 boolean remove(Object o); 18 19 boolean containsAll(Collection<?> c); 20 21 boolean addAll(Collection<? extends E> c); 22 23 boolean addAll(int index, Collection<? extends E> c); 24 25 boolean removeAll(Collection<?> c); 26 27 boolean retainAll(Collection<?> c); 28 29 void clear(); 30 31 boolean equals(Object o); 32 33 int hashCode(); 34 35 E get(int index); 36 37 E set(int index, E element); 38 39 void add(int index, E element); 40 41 E remove(int index); 42 43 int indexOf(Object o); 44 45 int lastIndexOf(Object o); 46 47 ListIterator<E> listIterator(); 48 49 ListIterator<E> listIterator(int index); 50 51 List<E> subList(int fromIndex, int toIndex); 52 }View Code
我們可以看到,在List接口中采用泛型化定義之後,<E>中的E表示類型形參,可以接收具體的類型實參,並且此接口定義中,凡是出現E的地方均表示相同的接受自外部的類型實參。
自然的,ArrayList作為List接口的實現類,其定義形式是:
1 public class ArrayList<E> extends AbstractList<E> 2 implements List<E>, RandomAccess, Cloneable, java.io.Serializable { 3 4 public boolean add(E e) { 5 ensureCapacityInternal(size + 1); // Increments modCount!! 6 elementData[size++] = e; 7 return true; 8 } 9 10 public E get(int index) { 11 rangeCheck(index); 12 checkForComodification(); 13 return ArrayList.this.elementData(offset + index); 14 } 15 16 //...省略掉其他具體的定義過程 17 18 }View Code
由此,我們從源代碼角度明白了為什麽//1處加入Integer類型對象編譯錯誤,且//2處get()到的類型直接就是String類型了。源碼get方法已經說明了返回的時T類型,無需強轉。
三.自定義泛型接口、泛型類和泛型方法
從上面的內容中,大家已經明白了泛型的具體運作過程。也知道了接口、類和方法也都可以使用泛型去定義,以及相應的使用。是的,在具體使用時,可以分為泛型接口、泛型類和泛型方法。
自定義泛型接口、泛型類和泛型方法與上述Java源碼中的List、ArrayList類似。如下,我們看一個最簡單的泛型類和方法定義:
1 public class GenericTest { 2 3 public static void main(String[] args) { 4 5 Box<String> name = new Box<String>("corn"); 6 System.out.println("name:" + name.getData()); 7 } 8 9 } 10 11 class Box<T> { 12 13 private T data; 14 15 public Box() { 16 17 } 18 19 public Box(T data) { 20 this.data = data; 21 } 22 23 public T getData() { 24 return data; 25 } 26 27 }View Code
在泛型接口、泛型類和泛型方法的定義過程中,我們常見的如T、E、K、V等形式的參數常用於表示泛型形參,由於接收來自外部使用時候傳入的類型實參。那麽對於不同傳入的類型實參,生成的相應對象實例的類型是不是一樣的呢?
1 public class GenericTest { 2 3 public static void main(String[] args) { 4 5 Box<String> name = new Box<String>("corn"); 6 Box<Integer> age = new Box<Integer>(712); 7 8 System.out.println("name class:" + name.getClass()); // com.qqyumidi.Box 9 System.out.println("age class:" + age.getClass()); // com.qqyumidi.Box 10 System.out.println(name.getClass() == age.getClass()); // true 11 12 } 13 14 }View Code
由此,我們發現,在使用泛型類時,雖然傳入了不同的泛型實參,但並沒有真正意義上生成不同的類型,傳入不同泛型實參的泛型類在內存上只有一個,即還是原來的最基本的類型(本實例中為Box),當然,在邏輯上我們可以理解成多個不同的泛型類型。
究其原因,在於Java中的泛型這一概念提出的目的,導致其只是作用於代碼編譯階段,在編譯過程中,對於正確檢驗泛型結果後,會將泛型的相關信息擦出,也就是說,成功編譯過後的class文件中是不包含任何泛型信息的。泛型信息不會進入到運行時階段。
對此總結成一句話:泛型類型在邏輯上看以看成是多個不同的類型,實際上都是相同的基本類型。
四.類型通配符
接著上面的結論,我們知道,Box<Number>和Box<Integer>實際上都是Box類型,現在需要繼續探討一個問題,那麽在邏輯上,類似於Box<Number>和Box<Integer>是否可以看成具有父子關系的泛型類型呢?
為了弄清這個問題,我們繼續看下下面這個例子:
1 public class GenericTest { 2 3 public static void main(String[] args) { 4 5 Box<Number> name = new Box<Number>(99); 6 Box<Integer> age = new Box<Integer>(712); 7 8 getData(name); 9 10 //The method getData(Box<Number>) in the type GenericTest is 11 //not applicable for the arguments (Box<Integer>) 12 getData(age); // 1 13 14 } 15 16 public static void getData(Box<Number> data){ 17 System.out.println("data :" + data.getData()); 18 } 19 20 }View Code
我們發現,在代碼//1處出現了錯誤提示信息:The method getData(Box<Number>) in the t ype GenericTest is not applicable for the arguments (Box<Integer>)。顯然,通過提示信息,我們知道Box<Number>在邏輯上不能視為Box<Integer>的父類。那麽,原因何在呢?
1 public class GenericTest { 2 3 public static void main(String[] args) { 4 5 Box<Integer> a = new Box<Integer>(712); 6 Box<Number> b = a; // 1 7 Box<Float> f = new Box<Float>(3.14f); 8 b.setData(f); // 2 9 10 } 11 12 public static void getData(Box<Number> data) { 13 System.out.println("data :" + data.getData()); 14 } 15 16 } 17 18 class Box<T> { 19 20 private T data; 21 22 public Box() { 23 24 } 25 26 public Box(T data) { 27 setData(data); 28 } 29 30 public T getData() { 31 return data; 32 } 33 34 public void setData(T data) { 35 this.data = data; 36 } 37 38 }View Code
這個例子中,顯然//1和//2處肯定會出現錯誤提示的。在此我們可以使用反證法來進行說明。
假設Box<Number>在邏輯上可以視為Box<Integer>的父類,那麽//1和//2處將不會有錯誤提示了,那麽問題就出來了,通過getData()方法取出數據時到底是什麽類型呢?Integer? Float? 還是Number?且由於在編程過程中的順序不可控性,導致在必要的時候必須要進行類型判斷,且進行強制類型轉換。顯然,這與泛型的理念矛盾,因此,在邏輯上Box<Number>不能視為Box<Integer>的父類。
好,那我們回過頭來繼續看“類型通配符”中的第一個例子,我們知道其具體的錯誤提示的深層次原因了。那麽如何解決呢?總部能再定義一個新的函數吧。這和Java中的多態理念顯然是違背的,因此,我們需要一個在邏輯上可以用來表示同時是Box<Integer>和Box<Number>的父類的一個引用類型,由此,類型通配符應運而生。
類型通配符一般是使用 ? 代替具體的類型實參。註意了,此處是類型實參,而不是類型形參!且Box<?>在邏輯上是Box<Integer>、Box<Number>...等所有Box<具體類型實參>的父類。由此,我們依然可以定義泛型方法,來完成此類需求。
1 public class GenericTest { 2 3 public static void main(String[] args) { 4 5 Box<String> name = new Box<String>("corn"); 6 Box<Integer> age = new Box<Integer>(712); 7 Box<Number> number = new Box<Number>(314); 8 9 getData(name); 10 getData(age); 11 getData(number); 12 } 13 14 public static void getData(Box<?> data) { 15 System.out.println("data :" + data.getData()); 16 } 17 18 }View Code
有時候,我們還可能聽到類型通配符上限和類型通配符下限。具體有是怎麽樣的呢?
在上面的例子中,如果需要定義一個功能類似於getData()的方法,但對類型實參又有進一步的限制:只能是Number類及其子類。此時,需要用到類型通配符上限。
1 public class GenericTest { 2 3 public static void main(String[] args) { 4 5 Box<String> name = new Box<String>("corn"); 6 Box<Integer> age = new Box<Integer>(712); 7 Box<Number> number = new Box<Number>(314); 8 9 getData(name); 10 getData(age); 11 getData(number); 12 13 //getUpperNumberData(name); // 1 14 getUpperNumberData(age); // 2 15 getUpperNumberData(number); // 3 16 } 17 18 public static void getData(Box<?> data) { 19 System.out.println("data :" + data.getData()); 20 } 21 22 public static void getUpperNumberData(Box<? extends Number> data){ 23 System.out.println("data :" + data.getData()); 24 } 25 26 }View Code
此時,顯然,在代碼//1處調用將出現錯誤提示,而//2 //3處調用正常。
類型通配符上限通過形如Box<? extends Number>形式定義,相對應的,類型通配符下限為Box<? super Number>形式,其含義與類型通配符上限正好相反,在此不作過多闡述了。
五.泛型特點 & 類型擦除
泛型只在編譯階段有效。看下面的代碼:
1 List<String> stringArrayList = new ArrayList<String>(); 2 List<Integer> integerArrayList = new ArrayList<Integer>(); 3 4 Class classStringArrayList = stringArrayList.getClass(); 5 Class classIntegerArrayList = integerArrayList.getClass(); 6 7 if(classStringArrayList.equals(classIntegerArrayList)){ 8 Log.d("泛型測試","類型相同"); 9 } 10 11 輸出結果:D/泛型測試: 類型相同。View Code
通過上面的例子可以證明,在編譯之後程序會采取去泛型化的措施。也就是說Java中的泛型,只在編譯階段有效。在編譯過程中,正確檢驗泛型結果後,會將泛型的相關信息擦出,並且在對象進入和離開方法的邊界處添加類型檢查和類型轉換的方法。也就是說,泛型信息不會進入到運行時階段。
對此總結成一句話:泛型類型在邏輯上看以看成是多個不同的類型,實際上都是相同的基本類型。
六.泛型面試題
1. Java中的泛型是什麽 ? 使用泛型的好處是什麽?
泛型是一種參數化類型的機制。它可以使得代碼適用於各種類型,從而編寫更加通用的代碼,例如集合框架。
泛型是一種編譯時類型確認機制。它提供了編譯期的類型安全,確保在泛型類型(通常為泛型集合)上只能使用正確類型的對象,避免了在運行時出現ClassCastException。
2、Java的泛型是如何工作的 ? 什麽是類型擦除 ?
泛型的正常工作是依賴編譯器在編譯源碼的時候,先進行類型檢查,然後進行類型擦除並且在類型參數出現的地方插入強制轉換的相關指令實現的。
編譯器在編譯時擦除了所有類型相關的信息,所以在運行時不存在任何類型相關的信息。例如List<String>在運行時僅用一個List類型來表示。為什麽要進行擦除呢?這是為了避免類型膨脹。
3. 什麽是泛型中的限定通配符和非限定通配符 ?
限定通配符對類型進行了限制。有兩種限定通配符,一種是<? extends T>它通過確保類型必須是T的子類來設定類型的上界,另一種是<? super T>它通過確保類型必須是T的父類來設定類型的下界。泛型類型必須用限定內的類型來進行初始化,否則會導致編譯錯誤。另一方面<?>表示了非限定通配符,因為<?>可以用任意類型來替代。
4. List<? extends T>和List <? super T>之間有什麽區別 ?
這和上一個面試題有聯系,有時面試官會用這個問題來評估你對泛型的理解,而不是直接問你什麽是限定通配符和非限定通配符。這兩個List的聲明都是限定通配符的例子,List<? extends T>可以接受任何繼承自T的類型的List,而List<? super T>可以接受任何T的父類構成的List。例如List<? extends Number>可以接受List<Integer>或List<Float>。
5. 如何編寫一個泛型方法,讓它能接受泛型參數並返回泛型類型?
編寫泛型方法並不困難,你需要用泛型類型來替代原始類型,比如使用T, E or K,V等被廣泛認可的類型占位符。泛型方法的例子請參閱Java集合類框架。最簡單的情況下,一個泛型方法可能會像這樣:
1 public V put(K key, V value) { 2 return cache.put(key, value); 3 }View Code
6. Java中如何使用泛型編寫帶有參數的類?
這是上一道面試題的延伸。面試官可能會要求你用泛型編寫一個類型安全的類,而不是編寫一個泛型方法。關鍵仍然是使用泛型類型來代替原始類型,而且要使用JDK中采用的標準占位符。
7. 編寫一段泛型程序來實現LRU緩存?
對於喜歡Java編程的人來說這相當於是一次練習。給你個提示,LinkedHashMap可以用來實現固定大小的LRU緩存,當LRU緩存已經滿了的時候,它會把最老的鍵值對移出緩存。LinkedHashMap提供了一個稱為removeEldestEntry()的方法,該方法會被put()和putAll()調用來刪除最老的鍵值對。
8. 你可以把List<String>傳遞給一個接受List<Object>參數的方法嗎?
對任何一個不太熟悉泛型的人來說,這個Java泛型題目看起來令人疑惑,因為乍看起來String是一種Object,所以List<String>應當可以用在需要List<Object>的地方,但是事實並非如此。真這樣做的話會導致編譯錯誤。如果你再深一步考慮,你會發現Java這樣做是有意義的,因為List<Object>可以存儲任何類型的對象包括String, Integer等等,而List<String>卻只能用來存儲Strings。
1 List<Object> objectList; 2 List<String> stringList; 3 4 objectList = stringList; //compilation error incompatible typesView Code
9. Array中可以用泛型嗎?
這可能是Java泛型面試題中最簡單的一個了,當然前提是你要知道Array事實上並不支持泛型,這也是為什麽Joshua Bloch在Effective Java一書中建議使用List來代替Array,因為List可以提供編譯期的類型安全保證,而Array卻不能。
10. 如何阻止Java中的類型未檢查的警告?
如果你把泛型和原始類型混合起來使用,例如下列代碼,Java 5的javac編譯器會產生類型未檢查的警告
,例如List<String> rawList = new ArrayList()
註意: Hello.java使用了未檢查或稱為不安全的操作;
這種警告可以使用@SuppressWarnings("unchecked")註解來屏蔽。
11、Java中List<Object>和原始類型List之間的區別?-----結合12題看
原始類型和帶參數類型<Object>之間的主要區別是,在編譯時編譯器不會對原始類型進行類型安全檢查,卻會對帶參數的類型進行檢查,通過使用Object作為類型,可以告知編譯器該方法可以接受任何類型的對象,比如String或Integer。這道題的考察點在於對泛型中原始類型的正確理解。它們之間的第二點區別是,你可以把任何帶參數的泛型類型傳遞給接受原始類型List的方法,但卻不能把List<String>傳遞給接受List<Object>的方法,因為會產生編譯錯誤。
1 package com.test.a; 2 3 import java.util.ArrayList; 4 import java.util.List; 5 6 public class Test { 7 public static void main(String[] args) { 8 9 List<Object> list1 = new ArrayList<Object>(); 10 List list2 = new ArrayList<>(); 11 List<String> list3 = new ArrayList<>(); 12 list1.add("a"); 13 list1.add(1); 14 list1.add(list3); 15 list2.add(list3); 16 for (Object i : list1) { 17 System.out.println(i); 18 } 19 List<?> listOfAnyType; 20 List<Object> listOfObject = new ArrayList<Object>(); 21 List<String> listOfString = new ArrayList<String>(); 22 List<Integer> listOfInteger = new ArrayList<Integer>(); 23 24 listOfAnyType = listOfString; // legal 25 listOfAnyType = listOfInteger; // legal 26 listOfAnyType = listOfObject; 27 28 listOfObjectType = (List<Object>) listOfString; // compiler error - in-convertible types 29 30 } 31 32 }View Code
12、Java中List<?>和List<Object>之間的區別是什麽?
這道題跟上一道題看起來很像,實質上卻完全不同。List<?> 是一個未知類型的List,而List<Object>其實是任意類型的List。你可以把List<String>, List<Integer>賦值給List<?>,卻不能把List<String>賦值給List<Object>。
List<?> listOfAnyType;
List<Object> listOfObject = new ArrayList<Object>();
List<String> listOfString = new ArrayList<String>();
List<Integer> listOfInteger = new ArrayList<Integer>();
listOfAnyType = listOfString; //legal
listOfAnyType = listOfInteger; //legal
listOfObjectType = (List<Object>) listOfString; //compiler error - in-convertible types
note:總結11題和12題:List<Object>是可以加入任何繼承該Object的元素的,比如list.add("String"). 但是List<String>和List<Object>確實兩種東西,無法將兩個引用視為一個引用。但是卻可以將List<String>的引用賦值給List<?>的引用。並且,所有的泛型只是在編譯器件有效,在經過編譯後,其實都是一個對象。比如:
Class class1=list1.getClass();
Class class2=list2.getClass();
Class class3=list3.getClass();
Class class4=listOfAnyType.getClass();
System.out.println((class1==class2)&&(class2==class3)&&(class3==class4));
打印結果就為true
13、List<String>和原始類型List之間的區別.
該題類似於“原始類型和帶參數類型之間有什麽區別”。帶參數類型是類型安全的,而且其類型安全是由編譯器保證的,但原始類型List卻不是類型安全的。你不能把String之外的任何其它類型的Object存入String類型的List中,而你可以把任何類型的對象存入原始List中。使用泛型的帶參數類型你不需要進行類型轉換,但是對於原始類型,你則需要進行顯式的類型轉換。
List listOfRawTypes = new ArrayList();
listOfRawTypes.add("abc");
listOfRawTypes.add(123); //編譯器允許這樣 - 運行時卻會出現異常
String item = (String) listOfRawTypes.get(0); //需要顯式的類型轉換
item = (String) listOfRawTypes.get(1); //拋ClassCastException,因為Integer不能被轉換為String
List<String> listOfString = new ArrayList();
listOfString.add("abcd");
listOfString.add(1234); //編譯錯誤,比在運行時拋異常要好
item = listOfString.get(0); //不需要顯式的類型轉換 - 編譯器自動轉換
六.話外篇
本文中的例子主要是為了闡述泛型中的一些思想而簡單舉出的,並不一定有著實際的可用性。另外,一提到泛型,相信大家用到最多的就是在集合中,其實,在實際的編程過程中,自己可以使用泛型去簡化開發,且能很好的保證代碼質量。並且還要註意的一點是,Java中沒有所謂的泛型數組一說。
對於泛型,最主要的還是需要理解其背後的思想和目的。
14. Java基礎之泛型