泛型

泛型：
      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：基本泛型

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.junit.Test;

public class GenericTest {

    @Test
    public void test1(){
        //下面操纵的list中的类型只能为String
        List<String> list = new ArrayList<String>();
        list.add("123");
        System.out.println(list.get(0));
    }
    
    @Test
    public void test2(){
        
        Map<Integer, String> map = new LinkedHashMap<Integer, String>();
        map.put(1, "A");
        map.put(2, "B");
        map.put(3, "C");
        map.put(4, "D");
        map.put(5, "E");
        
        Set<Entry<Integer,String>> entrySet = map.entrySet();
        for (Entry<Integer, String> entry : entrySet) {
            Integer key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + ":" + value);
        }
        
        Set<Integer> keySet = map.keySet();
        Iterator<Integer> iterator = keySet.iterator();
        while(iterator.hasNext()){
            Integer key = iterator.next();
            System.out.println(key + ":" + map.get(key));
        }
    }
}

例2：自定义泛型

public class GenericDemo {

    
    public void testMethod1(){
        testMethod("张三");
        testMethod(123);
    }
    
    /**
     * 自定义带泛型的方法，如下：   -->自定义泛型，首先要先声明即<T> ,后边的(T t)为使用<T>这个泛型
     * <T> 表示自定义的一个泛型，但未确切指定是什么类型，
     * 在调用这个方法的时候，传入的参数是什么类型，则“T”表示的就是什么类型
     * 如test1()中testMethod("张三")此时入参为String类型的，则“T”表示的类型就是String
     *             testMethod(123)为Integer类型，则“T”表示的类型就为Integer
     */
    public <T> T testMethod(T t){
        return null;
    }
    
    /**
     * 如下，多个泛型的方法
     */
    public <T,E,K> void testMethod2(T t,E e,K k){
        
    }
}

/**
 * 自定义类上的泛型
 * 类上也可以声明泛型，作用范围就是整个类
 */
class TestDemo<T>{
    
    public T test(){
        return null;
    }
    public <E> void test1(T t,E e){
        
    }
    
    /**
     * 静态的方法，不能够使用类上定义的泛型，如果使用必须得在静态方法上自定义，且在static之后
     */
    public static <T> void c(T t){
        
    }
}

例3：自定义泛型小例

import org.junit.Test;

public class GenericExample {

    @Test
    public void test1(){
        String[] arr = {"A","B","C","D","E","F"};
        genDemo(arr);
        Integer[] arrInt = {1,2,3,4,5,6,7};
        genDemo(arrInt);
    }
    
    
    //用泛型写一个方法，将一数组中的元素反转过来
    public <T> void genDemo(T arr[]){
        int len = arr.length - 1;
        int start = 0;
        while(true){
            if(start >= len){
                break;
            }
            T temp = arr[start];
            arr[start] = arr[len];
            arr[len] = temp;
            start ++;
            len --;
        }
        for (T t : arr) {
            System.out.println(t);
            //输出结果：FEDCBA7654321
        }
    }
}