泛型（Generic type 或者 generics）是對 java 語言的類型系統的一種擴展，以支持創建可以按類型進行參數化的類?？梢园杨愋蛥悼醋魇鞘褂脜祷愋蜁r指定的類型的一個占位符，就像方法的形式參數是運行時傳遞的值的占位符一樣。
泛型是Java SE 1.5的新特性，泛型的本質是參數化類型，也就是說所操作的數據類型被指定為一個參數。這種參數類型可以用在類、接口和方法的創建中，分別稱為泛型類、泛型接口、泛型方法。 Java語言引入泛型的好處是安全簡單。
在Java SE 1.5之前，沒有泛型的情況的下，通過對類型Object的引用來實現參數的“任意化”，“任意化”帶來的缺點是要做顯式的強制類型轉換，而這種轉換是要求開發者對實際參數類型可以預知的情況下進行的。對于強制類型轉換錯誤的情況，編譯器可能不提示錯誤，在運行的時候才出現異常，這是一個安全隱患。
泛型的好處是在編譯的時候檢查類型安全，并且所有的強制轉換都是自動和隱式的，以提高代碼的重用率。
可以在集合框架（Collection framework）中看到泛型的動機。例如，Map 類允許您向一個 Map添加任意類的對象，即使最常見的情況是在給定映射（map）中保存某個特定類型（比如 String）的對象。
因為 Map.get() 被定義為返回 Object，所以一般必須將 Map.get() 的結果強制類型轉換為期望的類型，如下面的代碼所示：
Map m = new HashMap(); m.put("key", "blarg"); String s = (String) m.get("key");要讓程序通過編譯，必須將 get() 的結果強制類型轉換為 String，并且希望結果真的是一個 String。但是有可能某人已經在該映射中保存了不是 String 的東西，這樣的話，上面的代碼將會拋出 ClassCastException。
理想情況下，您可能會得出這樣一個觀點，即 m 是一個 Map，它將 String 鍵映射到 String 值。這可以讓您消除代碼中的強制類型轉換，同時獲得一個附加的類型檢查層，該檢查層可以防止有人將錯誤類型的鍵或值保存在集合中。這就是泛型所做的工作。
package cn.itcast_01;import java.util.ArrayList;import java.util.Iterator;/* * ArrayList存儲字符串并遍歷 * * 我們按照正常的寫法來寫這個程序， 結果確出錯了。 * 為什么呢? * 因為我們開始存儲的時候，存儲了String和Integer兩種類型的數據。 * 而在遍歷的時候，我們把它們都當作String類型處理的，做了轉換，所以就報錯了。 * 但是呢，它在編譯期間卻沒有告訴我們。 * 所以，我就覺得這個設計的不好。 * 回想一下，我們的數組 * String[] strArray = new String[3]; * strArray[0] = "hello"; * strArray[1] = "world"; * strArray[2] = 10; * 集合也模仿著數組的這種做法，在創建對象的時候明確元素的數據類型。這樣就不會在有問題了。 * 而這種技術被稱為：泛型。 * * 泛型：是一種把類型明確的工作推遲到創建對象或者調用方法的時候才去明確的特殊的類型。參數化類型，把類型當作參數一樣的傳遞。 * 格式： * <數據類型> * 此處的數據類型只能是引用類型。 * 好處： * A:把運行時期的問題提前到了編譯期間 * B:避免了強制類型轉換 * C:優化了程序設計，解決了黃色警告線 */public class GenericDemo { public static void main(String[] args) { // 創建 ArrayList<String> array = new ArrayList<String>(); // 添加元素 array.add("hello"); array.add("world"); array.add("java"); // array.add(new Integer(100)); //array.add(10); // JDK5以后的自動裝箱 // 等價于：array.add(Integer.valueOf(10)); // 遍歷 Iterator<String> it = array.iterator(); while (it.hasNext()) { // ClassCastException // String s = (String) it.next(); String s = it.next(); System.out.PRintln(s); } // 看下面這個代碼 // String[] strArray = new String[3]; // strArray[0] = "hello"; // strArray[1] = "world"; // strArray[2] = 10; }}Java 語言中引入泛型是一個較大的功能增強。不僅語言、類型系統和編譯器有了較大的變化，以支持泛型，而且類庫也進行了大翻修，所以許多重要的類，比如集合框架，都已經成為泛型化的了。這帶來了很多好處：
泛型的主要目標是提高 Java 程序的類型安全。通過知道使用泛型定義的變量的類型限制，編譯器可以在一個高得多的程度上驗證類型假設。沒有泛型，這些假設就只存在于程序員的頭腦中（或者如果幸運的話，還存在于代碼注釋中）。
Java 程序中的一種流行技術是定義這樣的集合，即它的元素或鍵是公共類型的，比如“String 列表”或者“String 到 String 的映射”。通過在變量聲明中捕獲這一附加的類型信息，泛型允許編譯器實施這些附加的類型約束。類型錯誤現在就可以在編譯時被捕獲了，而不是在運行時當作 ClassCastException 展示出來。將類型檢查從運行時挪到編譯時有助于您更容易找到錯誤，并可提高程序的可靠性。
泛型的一個附帶好處是，消除源代碼中的許多強制類型轉換。這使得代碼更加可讀，并且減少了出錯機會。 盡管減少強制類型轉換可以降低使用泛型類的代碼的羅嗦程度，但是聲明泛型變量會帶來相應的羅嗦。
3、優化了程序設計，解決了黃色警告線
泛型是提供給javac編譯器使用的，可以限定集合中的輸入類型，讓編譯器擋住源程序中的非法輸入。但是，編譯器編譯帶類型說明的集合時會去除掉“類型”信息，目的就是使程序運行效率不受影響。因此，對于參數化的泛型類型，getClass()方法的返回值和原始類型完全一樣。
package com.itheima.day2;import java.util.ArrayList;public class GenericTest { public static void main(String[] args) { ArrayList<String> collection1 = new ArrayList<String>(); ArrayList collection2 = new ArrayList(); System. out.println(collection1.getClass() == collection2.getClass()); //結果：true }}由于編譯生成的字節碼會去掉泛型的類型信息，只要能跳過編譯器，就可以往某個泛型集合中加入其它類型的數據，例如，用反射得到集合，再調用其add方法即可。
package com.itheima.day2;import java.util.ArrayList;public class GenericTest { public static void main(String[] args) throws Exception { ArrayList<Integer> collection1 = new ArrayList<Integer>(); collection1.getClass().getMethod( "add",Object.class).invoke(collection1, "abc"); System. out.println(collection1.get(0)); }}ArrayList類定義和ArrayList類引用中涉及如下術語：
整個稱為ArrayList<E>泛型類型ArrayList<E>中的E稱為類型變量或類型參數整個ArrayList<Integer>稱為參數化的類型ArrayList<Integer>中的Integer稱為類型參數的實例或實際類型參數ArrayList<Integer>中的<>念著typeofArrayList稱為原始類型參數化類型與原始類型的兼容性：參數化類型可以引用一個原始類型的對象，編譯報告警告，例如
Collection<String> c = new Vector();//考慮到對以前代碼的兼容性，編譯器是可以通過的原始類型可以引用一個參數化類型的對象，編譯報告警告，例如
Collection c = new Vector<String>();//原來的方法接受一個集合參數，新的類型也要能傳進去參數化類型不考慮類型參數的繼承關系：
Vector<String> v = new Vector<Object>(); //錯誤!不寫<Object>沒錯，寫了就是明知故犯Vector<Object> v = new Vector<String>(); //也錯誤!注意：
假設Vector<String> v = new Vector<Object>();可以的話，那么以后從v中取出的對象當作String用，而v實際指向的對象中可以加入任意的類型對象；
假設Vector<Object> v = new Vector<String>();可以的話，那么以后可以向v中加入任意的類型對象，而v實際指向的集合中只能裝String類型的對象。
編譯器不允許創建泛型變量的數組。即在創建數組實例時，數組的元素不能使用參數化的類型。
例如，下面語句有錯誤：
Vector<Integer> vectorList[] = new Vector<Integer>[10];思考題：
下面的代碼會報錯誤嗎？
Vector v1 = new Vector<String>();Vector<Object> v = v1;答案：編譯的時候是不會報錯的，因為編譯器是一行一行按照語法檢查代碼的，因此不會出錯。
把泛型定義在類上，格式:public class 類名<泛型類型1,…>，注意:泛型類型必須是引用類型
package cn.itcast_04;/* * 泛型類的測試 */public class ObjectToolDemo { public static void main(String[] args) { // ObjectTool ot = new ObjectTool(); // // ot.setObj(new String("風清揚")); // String s = (String) ot.getObj(); // System.out.println("姓名是：" + s); // // ot.setObj(new Integer(30)); // Integer i = (Integer) ot.getObj(); // System.out.println("年齡是：" + i); // ot.setObj(new String("林青霞")); // // ClassCastException // Integer ii = (Integer) ot.getObj(); // System.out.println("姓名是：" + ii); System.out.println("-------------"); ObjectTool<String> ot = new ObjectTool<String>(); // ot.setObj(new Integer(27)); //這個時候編譯期間就過不去 ot.setObj(new String("林青霞")); String s = ot.getObj(); System.out.println("姓名是：" + s); ObjectTool<Integer> ot2 = new ObjectTool<Integer>(); // ot2.setObj(new String("風清揚"));//這個時候編譯期間就過不去 ot2.setObj(new Integer(27)); Integer i = ot2.getObj(); System.out.println("年齡是：" + i); }}//泛型類：把泛型定義在類上class ObjectTool<T> { private T obj; public T getObj() { return obj; } public void setObj(T obj) { this.obj = obj; }}把泛型定義在方法上，格式:public <泛型類型> 返回類型 方法名(泛型類型 .)
package cn.itcast_05;public class ObjectToolDemo { public static void main(String[] args) { // ObjectTool ot = new ObjectTool(); // ot.show("hello"); // ot.show(100); // ot.show(true); // ObjectTool<String> ot = new ObjectTool<String>(); // ot.show("hello"); // // ObjectTool<Integer> ot2 = new ObjectTool<Integer>(); // ot2.show(100); // // ObjectTool<Boolean> ot3 = new ObjectTool<Boolean>(); // ot3.show(true); // 定義泛型方法后 ObjectTool ot = new ObjectTool(); ot.show("hello"); ot.show(100); ot.show(true); }}//泛型方法：把泛型定義在方法上class ObjectTool { public <T> void show(T t) { System.out.println(t); }}把泛型定義在接口上，格式:public interface 接口名<泛型類型1…>
package cn.itcast_06;public class InterDemo { public static void main(String[] args) { // 第一種情況的測試 // Inter<String> i = new InterImpl(); // i.show("hello"); // // 第二種情況的測試 Inter<String> i = new InterImpl<String>(); i.show("hello"); Inter<Integer> ii = new InterImpl<Integer>(); ii.show(100); }}//泛型接口：把泛型定義在接口上 interface Inter<T> { public abstract void show(T t);}/實現類在實現接口的時候//第一種情況：已經知道該是什么類型的了//public class InterImpl implements Inter<String> {//// @Override// public void show(String t) {// System.out.println(t);// }// }//第二種情況：還不知道是什么類型的class InterImpl<T> implements Inter<T> { @Override public void show(T t) { System.out.println(t); }}為了解決類型被限制死了不能動態根據實例來確定的缺點，引入了“通配符泛型”，針對上面的例子，使用通配泛型格式為
package cn.itcast_07;import java.util.ArrayList;import java.util.Collection;/* * 泛型高級(通配符) * ?:任意類型，如果沒有明確，那么就是Object以及任意的Java類了 * ? extends E:向下限定，E及其子類 * ? super E:向上限定，E極其父類 */public class GenericDemo { public static void main(String[] args) { // 泛型如果明確的寫的時候，前后必須一致 Collection<Object> c1 = new ArrayList<Object>(); // Collection<Object> c2 = new ArrayList<Animal>(); // Collection<Object> c3 = new ArrayList<Dog>(); // Collection<Object> c4 = new ArrayList<Cat>(); // ?表示任意的類型都是可以的 Collection<?> c5 = new ArrayList<Object>(); Collection<?> c6 = new ArrayList<Animal>(); Collection<?> c7 = new ArrayList<Dog>(); Collection<?> c8 = new ArrayList<Cat>(); // ? extends E:向下限定，E及其子類 // Collection<? extends Animal> c9 = new ArrayList<Object>(); Collection<? extends Animal> c10 = new ArrayList<Animal>(); Collection<? extends Animal> c11 = new ArrayList<Dog>(); Collection<? extends Animal> c12 = new ArrayList<Cat>(); // ? super E:向上限定，E極其父類 Collection<? super Animal> c13 = new ArrayList<Object>(); Collection<? super Animal> c14 = new ArrayList<Animal>(); // Collection<? super Animal> c15 = new ArrayList<Dog>(); // Collection<? super Animal> c16 = new ArrayList<Cat>(); }}class Animal {}class Dog extends Animal {}class Cat extends Animal {}針對集合操作 的工具類，里面的方法都是靜態的，可以對集合進行排序、二分查找、反轉、混排等。
Collection:是單列集合的頂層接口，有子接口List和Set。Collections:是針對集合操作的工具類，有對集合進行排序和二分查找等方法
1、public static <T> void sort(List<T> list)
使用sort方法可以根據元素的自然順序 對指定列表按升序進行排序。列表中的所有元素都必須實現 Comparable 接口。此列表內的所有元素都必須是使用指定比較器可相互比較的
2、public static <T> int binarySearch(List<?> list,T key)
使用二分搜索法搜索指定列表，以獲得指定對象。
3、public static <T> T max(Collection<?> coll)
根據元素的自然順序，返回給定 collection 的最大元素。
4、public static void reverse(List<?> list)
反轉指定列表中元素的順序。
5、public static void shuffle(List<?> list)
混排算法所做的正好與 sort 相反: 它打亂在一個 List 中可能有的任何排列的蹤跡。也就是說，基于隨機源的輸入重排該 List, 這樣的排列具有相同的可能性（假設隨機源是公正的）。這個算法在實現一個碰運氣的游戲中是非常有用的。例如，它可被用來混排代表一副牌的 Card 對象的一個 List 。另外，在生成測試案例時，它也是十分有用的。
6、fill(List<? super T> list, T obj)
使用指定元素替換指定列表中的所有元素。
7、copy(List<? super T> dest, List<? extends T> src)
將所有元素從一個列表復制到另一個列表。用兩個參數，一個目標 List 和一個源 List, 將源的元素拷貝到目標，并覆蓋它的內容。目標 List 至少與源一樣長。如果它更長，則在目標 List 中的剩余元素不受影響。
8、集合線程安全化
List<T> synchronizedList(List<T> list);//返回支持的同步（線程安全的）List集合
Map<K,V> synchronizedMap(Map<K,V> m)：返回支持的同步（線程安全的）Map集合
package cn.itcast_01;import java.util.Collections;import java.util.List;import java.util.ArrayList;/* * Collections:是針對集合進行操作的工具類，都是靜態方法。 * * 面試題： * Collection和Collections的區別? * Collection:是單列集合的頂層接口，有子接口List和Set。 * Collections:是針對集合操作的工具類，有對集合進行排序和二分查找的方法 * * 要知道的方法 * public static <T> void sort(List<T> list)：排序 默認情況下是自然順序。 * public static <T> int binarySearch(List<?> list,T key):二分查找 * public static <T> T max(Collection<?> coll):最大值 * public static void reverse(List<?> list):反轉 * public static void shuffle(List<?> list):隨機置換 */public class CollectionsDemo { public static void main(String[] args) { // 創建集合對象 List<Integer> list = new ArrayList<Integer>(); // 添加元素 list.add(30); list.add(20); list.add(50); list.add(10); list.add(40); System.out.println("list:" + list); // public static <T> void sort(List<T> list)：排序 默認情況下是自然順序。 // Collections.sort(list); // System.out.println("list:" + list); // [10, 20, 30, 40, 50] // public static <T> int binarySearch(List<?> list,T key):二分查找 // System.out // .println("binarySearch:" + Collections.binarySearch(list, 30)); // System.out.println("binarySearch:" // + Collections.binarySearch(list, 300)); // public static <T> T max(Collection<?> coll):最大值 // System.out.println("max:"+Collections.max(list)); // public static void reverse(List<?> list):反轉 // Collections.reverse(list); // System.out.println("list:" + list); //public static void shuffle(List<?> list):隨機置換 Collections.shuffle(list); System.out.println("list:" + list); }}運行結果：
一、概述
此類包含用來操作數組（比如排序和搜索）的各種方法。此類還包含一個允許將數組作為列表來查看的靜態工廠。 二、常用方法
1、集合與數組的轉換
(1) 將數組轉換為集合
Lsit<T> asList(T… a);//返回一個受指定數組支持的固定大小的列表。
把數組變成List集合的好處：可以使用集合的思想和方法來操作數組中的元素。如：contains，get，indexOf，subList等方法。
PS:
將數組轉換成集合，不可使用集合的增刪方法，因為數組的長度是固定的。如果進行增刪操作，則會產生UnsupportedOperationException的編譯異常。如果數組中的元素都是對象，則變成集合時，數組中的元素就直接轉為集合中的元素。如果數組中的元素都是基本數據類型，那么會將該數組作為集合中的元素存在。(2) 集合轉數組
2、查找
int binarySearch()：使用二分搜索法來搜索指定的 byte 型數組，以獲得指定的值
3、判斷 boolean equals(Object[] a, Object[] a2)：判斷指定的兩個數組是否相等
4、排序 void sort()：對指定的數組按數字升序進行排序。
5、復制 <T> T[] copyOf(T[] original, int newLength) 復制指定的數組，截取或用 null 填充（如有必要），以使副本具有指定的長度。
6、填充 void fill(Object[] a, Object val) 將指定的 Object 引用分配給指定 Object 數組的每個元素。
7、其他方法 (1) toString(Object[] a)：返回指定數組內容的字符串表示形式。 (2) int hashCode(Object[] a) 基于指定數組的內容返回哈希碼。
package com.heima.test;import java.util.ArrayList;import java.util.Arrays;import java.util.List;public class Test { public static void main(String[] args) { System.out.println("1、將數組轉成集合"); System.out.println("-------------------"); // asList()將數組轉換為集合 List<Integer> list = Arrays.asList(87, 67, 65, 544); for (Integer i : list) { System.out.println(i); } System.out.println("2、二分查找"); System.out.println("-------------------"); // binarySearch()二分查找 int[] a = { 23, 45, 67, 8, 32, 45, 6, 7, 85, 54, 3, 432 }; int index = Arrays.binarySearch(a, 45); System.out.println(index); System.out.println("3、排序"); System.out.println("-------------------"); // sort()排序 System.out.println("排序前：" + Arrays.toString(a)); Arrays.sort(a); System.out.println("排序后：" + Arrays.toString(a)); System.out.println("4、集合轉成數組"); System.out.println("-------------------"); // toArray()集合轉成數組 ArrayList<String> al = new ArrayList<String>(); al.add("java"); al.add("javase"); al.add("php"); al.add("ruby"); al.add("android"); String[] str = al.toArray(new String[al.size()]); System.out.println(Arrays.toString(str)); }}運行結果： 
新聞熱點
疑難解答
