java 泛型学习随笔

对于java 泛型 编译时处理,运行时擦除的特点理解

• 对于编译时处理
  • 在使用泛型相关的类或方法时,如果声明时的类型和具体使用时的类型不一致则直接会编译不通过
• 对于运行时擦除
  • 当在运行时对两个相同类型但泛型的具体类型不同时,在运行时实际都是操作的相同的类型,而不会体现出来泛型的的具体类型;

　　　　

public static void main(String[] args){
 
  　　　 List a = Collections.emptyList();
        List b = Collections.emptyList();
        // true , 对于不包含泛型初始化的list实际都是使用的相同的实例数据
        LOGGER.info(String.valueOf(a == b));
 
        List<String> a1 = Collections.emptyList();
        boolean v = a == a1;
        // true, 对于 a 和 a1 两个参数的类型实际是不同的,但在运行时实际是对于a和a1的类型实际都是相同的List类型; 可以通过 javap -v 类名 来查看编译后的class文件
        LOGGER.info(String.valueOf(v));
 
        List<Integer> b1 = Collections.emptyList();
        // 由于a1和b1的泛型的具体类型不一致,因此在编译时不会通过
//        boolean v1 = a1 == b1
}

　　对于泛型的显式限定和隐式限定区别

 public static void castQuestion() {
        // 在执行实例化操作时,实际已经隐式限定了当前对象的类型
        // 在执行具体操作时,虽然根据变量的限定符显式定义,但在实际使用中就会抛出错误
        Container<StringBuilder> stringContainer = new Container("1");
        StringBuilder element = stringContainer.getElement();
 
    }
 
    // 自定义内部容器类,类型为泛型
    // 单界限操作: E extends CharSequence,这里限定了泛型的类型只能为CharSequence的子级
    public static class Container<E extends Serializable> {
        private E element;
 
        public Container(E element) {
            this.element = element;
            // 可以看到当前元素的实际类型
            System.out.println(element.getClass().getTypeName());
        }
 
        // 方法
        public E getElement() {
            return element;
        }
 
        public void setElement(E element) {
            this.element = element;
        }
    }

　　可以看到在指定 new 时未显式指定对象元素类型,但通过调用有参构造方法实际已限定了当前对象的element元素类型;

　　虽然对象变量显式限定了当前变量的泛型,对于操作方法实际是根据调用者的具体泛型类型进行限制,因此可以看到 "StringBuilder element = stringContainer.getElement();" 返回值类型为 StringBuilder;

　　而由于对象中的实际类型为String类型,当将String类型强制赋值为Integer类型数据时,就会抛出ClassCastException

由于泛型存在编译时校验,运行时擦写的特点,因此为了保证运行时也提供泛型类型校验, 在Collections中提供了 checked*的工具类,在执行操作时保证了运行时的类型校验

    public void collectionGenericType() {
        List<Integer> integers = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
        // 由于泛型存在编译时校验,运行时擦写
        List noGenericTypeList = integers;
        System.out.println(noGenericTypeList == integers);
        // 虽然 noGenericTypeList 引用了 integers
        // 运行时泛型擦写  List<Integer> -> List<Object> -> List
        // 因此可以写入任意类型的数据
        noGenericTypeList.add("A");
        // 由于数据读取时需要进行类型转换(转换为泛型的指定类型)因此会抛出ClassCastException
//        integers.forEach(System.out::println);
        // 而对于noGenericTypeList由于没有泛型的约束,因此读取数据是都是按照Object类型处理
        noGenericTypeList.forEach(System.out::println);
        // 在转换时并没有执行类型检查因此支持直接转换
        List<Integer> castList = new ArrayList<>(noGenericTypeList);
        // 因此为了避免类型擦写导致的异常,因此需要使用包装类型工具类
        // 当转换为checkedList时并不会进行类型校验
        /**
         * Wrapper(装饰器)模式的使用
         * Collections.checked*接口弥补了 泛型运行时擦写的不足
         * 强类型: 编译时泛型强制类型检查,运行时利用Collections.checked*强类型检查
         */
        List<Integer> checkedList = Collections.checkedList(castList, Integer.TYPE);
        // 会生成新的数据
        System.out.println(checkedList == castList);
 
        noGenericTypeList = checkedList;
        // 对于checkedList在执行添加时,会执行类型校验,因此会直接抛出错误
        noGenericTypeList.add("B");
    }