1. 泛型究竟是什么？
在討論類型推導(type inference)之前，必須回顧一下什么是泛型(Generic).泛型是Java SE 1.5的新特性，泛型的本質是參數化類型，也就是說所操作的數據類型被指定為一個參數。通俗點將就是“類型的變量”。這種類型變量可以用在類、接口和方法的創建中。理解Java泛型最簡單的方法是把它看成一種便捷語法，能節省你某些Java類型轉換(casting)上的操作：
|
1
2
|
List<Apple> box = new ArrayList<Apple>();box.add(new Apple());Apple apple =box.get(0); |
上面的代碼自身已表達的很清楚：box是一個裝有Apple對象的List。get方法返回一個Apple對象實例，這個過程不需要進行類型轉換。沒有泛型，上面的代碼需要寫成這樣：
|
1
|
Apple apple = (Apple)box.get(0); |
當然，泛型絕不像我在這里描述的這么簡單，但這不是我們今天的主角，對于泛型還不是很明白的同學需要補課了～當然，最好的參考資料還是官方文檔。
2. 泛型帶來的問題（Java 7之前）
泛型的最大優點是提供了程序的類型安全同時可以向后兼容，但也有讓開發者不爽的地方，就是每次定義時都要寫明泛型的類型，這樣顯示指定不僅感覺有些冗長，最主要是很多程序員不熟悉泛型，因此很多時候不能夠給出正確的類型參數，現在通過編譯器自動推斷泛型的參數類型，能夠減少這樣的情況，并提高代碼可讀性。
3. Java 7中對于泛型的類型推導方面的改進
在Java 7以前的版本中使用泛型類型，需要在聲明并賦值的時候，兩側都加上泛型類型。比方說這樣：
|
1
|
Map<String,Integer> map = new HashMap<String,Integer>(); |
很多人當初肯定和我一樣，對此感到很不解：我在變量聲明中不是已經聲明了參數類型了嗎？為什么在對象初始化的時候還要顯示的寫出來？這也是泛型在一開始出現的時候受到很多人吐槽的地方。不過，讓人欣慰的是，java在進步的同時，那些設計者們也在不斷的改進java的編譯器，讓它變的更加智能與人性化。這里，就是我們今天的主角：類型推倒...額...不是推倒，是類型推導，即type inference，這哥們兒的出現，再寫上面這樣的代碼的時候，可以很開心地省略掉對象實例化時的參數類型，也就變成了這個樣子：
|
1
|
Map<String,Integer> map = new HashMap<>(); |
在這條語句中，編譯器會根據變量聲明時的泛型類型自動推斷出實例化HashMap時的泛型類型。再次提醒一定要注意new HashMap后面的“<>”，只有加上這個“<>”才表示是自動類型推斷，否則就是非泛型類型的HashMap，并且在使用編譯器編譯源代碼時會給出一個警告提示（unchecked conversion warning）。這一對尖括號"<>"官方文檔中叫做"diamond"。
但是，這時候的類型推導做的并不完全（甚至算是一個半成品），因為在Java SE 7中創建泛型實例時的類型推斷是有限制的：只有構造器的參數化類型在上下文中被顯著的聲明了，才可以使用類型推斷，否則不行。例如：下面的例子在java 7無法正確編譯（但現在在java8里面可以編譯，因為根據方法參數來自動推斷泛型的類型）：
|
1
2
3
|
List<String> list = new ArrayList<>();list.add("A");// 由于addAll期望獲得Collection<? extends String>類型的參數，因此下面的語句無法通過list.addAll(new ArrayList<>()); |
4. 在Java8中的再進化
在最新的java官方文檔之中，我們可以看到對于類型推導的定義：
Type inference is a Java compiler's ability to look at each method invocation and corresponding declaration to determine the type argument (or arguments) that make the invocation applicable. The inference algorithm determines the types of the arguments and, if available, the type that the result is being assigned, or returned. Finally, the inference algorithm tries to find the most specific type that works with all of the arguments.
簡言之，類型推導也就是指編譯器能夠根據你調用的方法和相應的聲明來確定需要的參數類型的能力。并且官方文檔中還給出了一個例子加以詮釋：
|
1
2
|
static <T> T pick(T a1, T a2) { return a2; }Serializable s = pick("d", new ArrayList<String>()); |
在這里，編譯器能夠推導出傳入pick方法中的第二個參數的類型是Serializable的。
在之前的java版本當中，上面的例子要能夠通過編譯的話需要這要寫：
|
1
|
Serializable s = this.<Serializable>pick("d", new ArrayList<String>()); |
這樣寫的詳細原因可以在Bruce Eckel的java編程思想（第四版）的泛型一章看得到，當然這本書是基于java6的，這個版本還沒有類型推導這個概念。看到這里，很多人已經明顯能看得出來最新版本中類型推導的強力之處了。已經不僅僅局限于泛型類的聲明與實例化過程了，而是延伸到了具有泛型參數的方法當中了。
4.1 類型推導和泛型方法（Type Inference and Generic Methods）
關于新版本中的類型推導和泛型方法，文檔中還給了一個稍微復雜一點的例子，我在這里貼出來，原理和上面的Serializable例子都是一樣就不再贅述，想鞏固的可以再看一下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
public class BoxDemo { public static <U> void addBox(U u, java.util.List<Box<U>> boxes) { Box<U> box = new Box<>(); box.set(u); boxes.add(box); } public static <U> void outputBoxes(java.util.List<Box<U>> boxes) { int counter = 0; for (Box<U> box: boxes) { U boxContents = box.get(); System.out.println("Box #" + counter + " contains [" + boxContents.toString() + "]"); counter++; } } public static void main(String[] args) { java.util.ArrayList<Box<Integer>> listOfIntegerBoxes = new java.util.ArrayList<>(); BoxDemo.<Integer>addBox(Integer.valueOf(10), listOfIntegerBoxes); BoxDemo.addBox(Integer.valueOf(20), listOfIntegerBoxes); BoxDemo.addBox(Integer.valueOf(30), listOfIntegerBoxes); BoxDemo.outputBoxes(listOfIntegerBoxes); }} |
上面這段代碼輸出為：
|
1
2
3
|
Box #0 contains [10]Box #1 contains [20]Box #2 contains [30] |
提一下，泛型方法addBox重點就在于在新java版本中你不需要再在方法調用中進行顯示的類型說明，像這樣：
|
1
|
BoxDemo.<Integer>addBox(Integer.valueOf(10), listOfIntegerBoxes); |
編譯器能夠從傳入addBox中的參數自動推斷出參數類型是Integer.
4.2 類型推導與泛型類和非泛型類的泛型構造器(Type Inference and Generic Constructors of Generic and Non-Generic Classes)
額...這個也許英語的更好斷句一點：Type Inference and Generic Constructors of Generic and Non-Generic Classes
其實，泛型構造器并不是泛型類的專利品，非泛型類也完全可以有自己的泛型構造器，看一下這個例子：
|
1
2
3
4
5
|
class MyClass<X> { <T> MyClass(T t) { // ... }} |
假如對 MyClass類做出下面這樣的實例化：
|
1
|
new MyClass<Integer>("") |
OK，這里我們顯示地指出了MyClass的泛參類型X是Integer，而對于構造器，編譯器根據傳入的String對象（""）推導出形式參數T是String，這個在java7版本之中已經實現了，在Java8中有了什么改進呢？在Java8之后，對于這種具有泛型構造器的泛型類的實例化我們可以這么寫：
|
1
|
MyClass<Integer> myObject = new MyClass<>(""); |
對，還是這一對尖括號（<>），江湖人稱diamond，這樣我們的編譯器就能夠自動推導出形式參數X是Integer，T是String了。這個其實和我們一開始Map<String,String>的例子很像，只是多了個構造器的泛型化。
需要注意的是：類型推導只能根據調用的參數類型、目標類型（這個馬上會講到）和返回類型（如果有返回的話）進行推導，而不能根據程序后面的一些需求來進行推導。
4.3 目標類型(Target Type)
前文已經提到過，編譯器能夠根據目標類型進行類型推導。一個表達式的目標類型指的是一種編譯器根據表達式出現的位置而需要的正確的數據類型。比如這個例子：
|
1
2
|
static <T> List<T> emptyList();List<String> listOne = Collections.emptyList(); |
在這里，List<String>就是目標類型，因為這里需要的是List<String> ，而Collections.emptyList()返回的是List<T> ，所以這里編譯器就推斷T一定是String。這個在Java 7 和 8 中都OK。但是在java 7 中，在下面這種情況中就不能正常編譯了：
|
1
2
3
4
5
|
void processStringList(List<String> stringList) { // process stringList}processStringList(Collections.emptyList()); |
這個時候，java7就會給出這種錯誤提示：
|
1
|
//List<Object> cannot be converted to List<String> |
原因：Collections.emptyList() 返回的是List<T> ，這里的T需要一個具體類型，但是因為不能從方法聲明中推斷出所需的是String，所以編譯器就給T了一個Object的值，很明顯，List<Object>不能轉型到List<String>.所以在java7版本中你需要這樣調用這個方法：
|
1
|
processStringList(Collections.<String>emptyList()); |
但是，在java8中，由于目標類型概念的引入，這里，很明顯編譯器需要的是List<String> （也就是這里的Target Type），所以編譯器推斷返回的List<T>中的T一定是String，所以processStringList(Collections.emptyList());這種描述是OK的。
目標類型的使用在Lambda表達式中優勢最為明顯。
總結
好了，以上就是關于java中類型推導的一些個人見解，總結來說，越來越完善的類型推導就是完成了一些本來就感覺很理所當然的類型轉換工作，只是這些工作滿滿地全交給了編譯器去自動推導而不是讓開發者顯示地去指定。希望這篇文章的內容對大家學習Java能有所幫助，如果有疑問可以留言交流。
