Java - 泛型

1、使用泛型中出现的类型转换问题

	@Test
    public void test1(){
        ArrayList list = new ArrayList();
        list.add(78);
        list.add(74);
        list.add(76);
        list.add(79);
        // 问题一：类型不安全
        list.add("Tom");

        for (Object score : list) {
            // 问题二：强转时，可能出现ClassCastException类型转换异常
            // java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
            int stuScore = (Integer) score;
            log.info("返回结果：{}" ,stuScore);
        }
    }

2、在集合中使用泛型（Map集合）

1、注意点：泛型的类型必须是类。不能是基本数据类型。需要用到基本数据类型的位置，使用基本数据类型的包装类。

2、如果实例化时，没有指明泛型的类型，默认类型为java.lang.Object类型。

@Test
public void test3(){
    // HashMap中不需要再声明类型，是因为java7中添加了类型推断
    Map<String, Integer> map = new HashMap<>();

    map.put("Tom",221);
    map.put("Jerry",345);
    map.put("Jack",321);
    map.put("Mary",654);
    // 泛型的嵌套
    Set<Map.Entry<String, Integer>> entries = map.entrySet();
    Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
    while (iterator.hasNext()){
        Map.Entry<String, Integer> entry = iterator.next();
        String key = entry.getKey();
        Integer value = entry.getValue();
        log.info("key:{},value:{}",key,value);
    }
}

3、如何自定义泛型结构：泛型类、泛型接口、泛型方法

1、自定义泛型类

public class Order<T> {
    String orderName;
    int orderId;

    // 类的内部结构就可以使用类的泛型
    T orderT;

    public Order() {
    }

    public Order(String orderName, int orderId, T orderT) {
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

    public T getOrderT() {
        return orderT;
    }

    public void setOrderT(T orderT) {
        this.orderT = orderT;
    }
}

2、测试类

public class GenericTest1 {

    @Test
    public void test1(){
        // 建议：实例化时指明类的泛型
        Order<String> order = new Order<>();
        order.setOrderT("order:aa");
    }
}

3、注意点

4、泛型方法

1、自定义泛型方法

	/**
     * 泛型方法
     *  泛型方法所属的类是不是泛型类都没关系
     *
     * @param arr
     * @param <E>
     * @return
     */
    public <E> List<E> copyFromArrayToList(E[] arr) {
        ArrayList<E> list = new ArrayList<>();
        for (E e : arr) {
            list.add(e);
        }
        return list;
    }

2、测试类

	@Test
    public void test2(){
        Order order = new Order();
        Integer[] arr = {1, 2, 3, 4, 5, 6};
        List list = order.copyFromArrayToList(arr);
        System.out.println(list); // [1, 2, 3, 4, 5, 6]
    }

3、总结：

• 泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的，并非在实例化类是确定的。
• 泛型方法所属的类是不是泛型类都没有关系。
• 泛型方法中出现的泛型结构，泛型参数与类的泛型参数没有任何关系。

5、泛型在继承方面的体现

虽然类A是类B的父类，但是G<A> 和G<B>二者不具备子父类关系，二者是并列的关系。

6、通配符使用

1、类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是：G<?>

2、添加(写入)：对于List<?> 就不能向其内部添加数据，除了添加null之外。

3、获取(读取)：允许读取数据，读取的数据类型为Object。

 	/**
     * 通配符的使用
     * 通配符：?
     */
    @Test
    public void test4() {
        List<Object> objList = new ArrayList<>();
        List<String> strList = new ArrayList<>();

        objList.add(123);
        objList.add(345);
        objList.add(567);
        objList.add(126783);

        strList.add("asd");
        strList.add("xcv");
        strList.add("sdf");
        strList.add("xcvf");

        List<?> list = null;
        list = objList;
        list = strList;

        print(strList);
        System.out.println("---------------------");
        print(objList);
        
        System.out.println("-----------------");
        Object o = list.get(0);
        System.out.println(o); // asd
    }

    public void print(List<?> list){
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()){
            Object obj = iterator.next();
            System.out.println(obj);
        }
    }

打印结果：
asd
xcv
sdf
xcvf
---------------------
123
345
567
126783
-----------------
asd