泛型

泛型：
      jdk5之前，對象保存到集合中就會失去其特性，取出時一般要程序員時行類型的強制轉換，這樣，不可避免就會引起程序的一些安全性問題。
如：
      ArrayList list = new ArrayList();
      list.add("aaa");
      Integer num = (Integer)list.get(0);  //運行時會出錯，但編碼時發現不了

      jdk5中的泛型容許程序員在編寫集合代碼時，就限制集合的處理類型，從而把原來程序運行時可能發生的問題，轉變爲編譯時的問題，以提升程序的穩定性和可讀性（尤爲在大型程序中更爲突出）。

      在使用泛型時泛型類型必須爲引用類型，不能是基本數據類型。
      若是兩邊都使用了泛型，泛型的類型必須一致，但能夠一邊使用泛型，另外一邊不使用
      注：泛型是提供給javac編譯器使用的，它用於限制集合的輸入類型，讓編譯器在源代碼級別上，擋住向集合中插入非法數據。但編譯器編譯完帶有泛型的java程序後，生成的class文件再也不帶有泛型信息，以此使程序運行效率不受影響，這個過程稱之爲「擦除」。

泛型的基本術語

• 以ArrayList<E>爲例：<>讀爲「typeof」
• ArrayList<E>中的E稱爲類型參數變量
• ArrayList<Integer>中的Integer 稱爲實際類型參數
• 整個ArrayList<E>稱爲泛型類型
• 整個ArrayList<Integer>稱爲參數化的類型ParameterizedType

例1：基本泛型

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 import java.util.LinkedHashMap;
 4 import java.util.List;
 5 import java.util.Map;
 6 import java.util.Map.Entry;
 7 import java.util.Set;
 8 
 9 import org.junit.Test;
10 
11 public class GenericTest {
12 
13     @Test
14     public void test1(){
15         //下面操縱的list中的類型只能爲String
16         List<String> list = new ArrayList<String>();
17         list.add("123");
18         System.out.println(list.get(0));
19     }
20     
21     @Test
22     public void test2(){
23         
24         Map<Integer, String> map = new LinkedHashMap<Integer, String>();
25         map.put(1, "A");
26         map.put(2, "B");
27         map.put(3, "C");
28         map.put(4, "D");
29         map.put(5, "E");
30         
31         Set<Entry<Integer,String>> entrySet = map.entrySet();
32         for (Entry<Integer, String> entry : entrySet) {
33             Integer key = entry.getKey();
34             String value = entry.getValue();
35             System.out.println(key + ":" + value);
36         }
37         
38         Set<Integer> keySet = map.keySet();
39         Iterator<Integer> iterator = keySet.iterator();
40         while(iterator.hasNext()){
41             Integer key = iterator.next();
42             System.out.println(key + ":" + map.get(key));
43         }
44     }
45 }

例2：自定義泛型

 1 public class GenericDemo {
 2 
 3     
 4     public void testMethod1(){
 5         testMethod("張三");
 6         testMethod(123);
 7     }
 8     
 9     /**
10      * 自定義帶泛型的方法，以下：   -->自定義泛型，首先要先聲明即<T> ,後邊的(T t)爲使用<T>這個泛型
11      * <T> 表示自定義的一個泛型，但未確切指定是什麼類型，
12      * 在調用這個方法的時候，傳入的參數是什麼類型，則「T」表示的就是什麼類型
13      * 如test1()中testMethod("張三")此時入參爲String類型的，則「T」表示的類型就是String
14      *             testMethod(123)爲Integer類型，則「T」表示的類型就爲Integer
15      */
16     public <T> T testMethod(T t){
17         return null;
18     }
19     
20     /**
21      * 以下，多個泛型的方法
22      */
23     public <T,E,K> void testMethod2(T t,E e,K k){
24         
25     }
26 }
27 
28 /**
29  * 自定義類上的泛型
30  * 類上也能夠聲明泛型，做用範圍就是整個類
31  */
32 class TestDemo<T>{
33     
34     public T test(){
35         return null;
36     }
37     public <E> void test1(T t,E e){
38         
39     }
40     
41     /**
42      * 靜態的方法，不可以使用類上定義的泛型，若是使用必須得在靜態方法上自定義，且在static以後
43      */
44     public static <T> void c(T t){
45         
46     }
47 }

例3：自定義泛型小例

 1 import org.junit.Test;
 2 
 3 public class GenericExample {
 4 
 5     @Test
 6     public void test1(){
 7         String[] arr = {"A","B","C","D","E","F"};
 8         genDemo(arr);
 9         Integer[] arrInt = {1,2,3,4,5,6,7};
10         genDemo(arrInt);
11     }
12     
13     
14     //用泛型寫一個方法，將一數組中的元素反轉過來
15     public <T> void genDemo(T arr[]){
16         int len = arr.length - 1;
17         int start = 0;
18         while(true){
19             if(start >= len){
20                 break;
21             }
22             T temp = arr[start];
23             arr[start] = arr[len];
24             arr[len] = temp;
25             start ++;
26             len --;
27         }
28         for (T t : arr) {
29             System.out.println(t);
30             //輸出結果：FEDCBA7654321
31         }
32     }
33 }