• 欢迎访问 winrains 的个人网站!
  • 本网站主要从互联网整理和收集了与Java、网络安全、Linux等技术相关的文章,供学习和研究使用。如有侵权,请留言告知,谢谢!

深入理解Java泛型

Java技术 winrains 来源:程序员小黑 10个月前 (02-07) 45次浏览

泛型

泛型提供了一种将集合类型传达给编译器的方法,一旦编译器知道了集合元素的类型,编译器就可以对其类型进行检查,做类型约束。

在没有泛型之前:

/**
 * 迭代 Collection ,注意 Collection 里面只能是 String 类型
 */
public static void forEachStringCollection(Collection collection) {
    Iterator iterator = collection.iterator();
    while (iterator.hasNext()) {
        String next = (String) iterator.next();
        System.out.println("next string : " + next);
    }
}

这是使用泛型之后的程序:

public static void forEachCollection(Collection<String> collection) {
    Iterator<String> iterator = collection.iterator();
    while (iterator.hasNext()) {
        String next = iterator.next();
        System.out.println("next string : " + next);
    }
}

在没有泛型之前,我们只能通过更直观的方法命名和 doc 注释来告知方法的调用者,forEachStringCollection方法只能接收元素类型为String的集合。然而这只是一种“约定”,如果使用方传入了一个元素不为String类型的集合,在编译期间代码并不会报错,只有在运行时,会抛出ClassCastException异常,这对调用方来说并不友好。

通过泛型,可以将方法的 doc 注释转移到了方法签名上:forEachCollection(Collection<String> collection),方法调用者一看方法签名便知道此处需要一个Collection<String>,编译器也可以在编译时检查是否违反类型约束。需要说明的是,编译器的检查也是非常容易绕过的,如何绕过呢?请看下文哦~

画外音:代码就是最好的注释。

泛型和类型转化

思考,以下代码是否合法:

List<String> strList = new ArrayList<>();
List<Object> objList = new ArrayList<>();
objList.add("公众号:Coder小黑"); // 代码1
objList = strList; // 代码2

废话不多说,直接上答案。

image.png

代码1很明显是合法的。Object类型是String类型的父类。

那么代码2为什么不合法呢?

在 Java 中,对象类型的赋值其实是引用地址的赋值,也就是说,假设代码2赋值成功,objListstrList变量引用的是同一个地址。那会有什么问题呢?

如果此时,往objList中添加了一个非String类型的元素,也就相当于往strList中添加了一个非String类型的元素。很明显,此处就破坏了List<String> strList。所以,Java 编译器会认为代码2是非法的,这是一种安全的做法。

画外音:可能和大多数人的直觉不太一样,那是我们考虑问题还不够全面,此处的原因比结果更重要哦

泛型通配符

我们已经知道,上文的代码2是不合法的。那么,接下来思考这样两个方法:

public static void printCollection1(Collection c) {}

public static void printCollection2(Collection<Object> c) {}

这两个方法有什么区别呢?

printCollection1方法支持任意元素类型的Collection,而printCollection2方法只能接收Object类型的Collection。虽然StringObject的子类,但是Collection<String>并不是Collection<Object>的子类,和代码2有异曲同工之妙。

再看一下下面这个方法:

public static void printCollection3(Collection<?> c) {}

printCollection3和上面的两个方法又有什么区别呢?怎么理解printCollection3方法上的?呢?

?表示任意类型,表明printCollection3方法接收任意类型的集合。

好,那么问题又来了,请看如下代码:

List<?> c = Lists.newArrayList(new Object());
Object o = c.get(0);
c.add("12"); // 编译错误

为什么会编译报错呢?

我们可以将任意类型的集合赋值给List<?> c变量。但是,add方法的参数类型是,它表示未知类型,所以调用add方法时会编程错误,这是一种安全的做法。

get方法返回集合中的元素,虽然集合中的元素类型未知,但是无论是什么类型,其均为Object类型,所以使用Object类型来接收是安全的。

有界通配符

public static class Person extends Object {}

public static class Teacher extends Person {}

// 只知道这个泛型的类型是Person的子类,具体是哪一个不知道
public static void method1(List<? extends Person> c) {}

// 只知道这个泛型的类型是Teacher的父类,具体是哪一个不知道
public static void method2(List<? super Teacher> c) {}

思考如下代码运行结果:

public static void test3() {
    List<Teacher> teachers = Lists.newArrayList(new Teacher(), new Teacher());
    // method1 处理的是 Person 的 子类,Teacher 是 Person 的子类
    method1(teachers);
}

// 只知道这个泛型的类型是Person的子类,具体是哪一个不知道
public static void method1(List<? extends Person> c) {
    // Person 的子类,转Person, 安全
    Person person = c.get(0);
    c.add(new Person()); // 代码3,编译错误
}

代码3为什么会编译错误呢?

method1只知道这个泛型的类型是Person的子类,具体是哪一个不知道。如果代码3编译成功,那么上述的代码中,就是往List<Teacher> teachers中添加了一个Person元素。此时,后续在操作List<Teacher> teachers时,大概率会抛出ClassCastException异常。

再来看如下代码:

public static void test4() {
    List<Person> teachers = Lists.newArrayList(new Teacher(), new Person());
    // method1 处理的是 Person 的 子类,Teacher 是 Person 的子类
    method2(teachers);
}

// 只知道这个泛型的类型是Teacher的父类,具体是哪一个不知道
public static void method2(List<? super Teacher> c) {
    // 具体是哪一个不知道, 只能用Object接收
    Object object = c.get(0); // 代码4
    c.add(new Teacher()); // 代码5,不报错
}

method2泛型类型是Teacher的父类,而Teacher的父类有很多,所以代码4只能使用Object来接收。子类继承父类,所以往集合中添加一个Teacher对象是安全的操作。

最佳实践:PECS 原则

PECS:producer extends, consumer super

  • 生产者,生产数据的, 使用<? extends T>
  • 消费者,消费数据的,使用<? super T>

怎么理解呢?我们直接上代码:

/**
 * producer - extends, consumer- super
 */
public static void addAll(Collection<? extends Object> producer,
                          Collection<? super Object> consumer) {
    consumer.addAll(producer);
}

有同学可能会说,这个原则记不住怎么办?

没关系,笔者有时候也记不清。不过幸运的是,在 JDK 中有这个一个方法:java.util.Collections#copy,该方法很好的阐述了 PECS 原则。每次想用又记不清的时候,看一眼该方法就明白了~

// java.util.Collections#copy
public static <T> void copy(List<? super T> dest, List<? extends T> src){}

画外音:知识很多、很杂,我们应该在大脑中建立索引,遇到问题,通过索引来快速查找解决方法

更安全的泛型检查

上述的一些检查都是编译时的检查,而想要骗过编译器的检查也很简单:

public static void test5() {
    List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
    List copy = list;
    copy.add("a");
    List<Integer> list2 = copy;
}

test5方法就骗过了编译器,而且能成功运行。

那什么时候会报错呢?当程序去读取list2中的元素时,才会抛出ClassCastException异常。

Java 给我们提供了java.util.Collections#checkedList方法,在调用add时就会检查类型是否匹配。

public static void test6() {
    List<Integer> list = Collections.checkedList(Arrays.asList(1, 2, 3, 4, 5), Integer.class);
    List copy = list;
    // Exception in thread "main" java.lang.ClassCastException: Attempt to
    // insert class java.lang.String element into collection with element
    // type class java.lang.Integer
    copy.add("a");
}

画外音:这是一种 fail-fast 的思想,在 add 时发现类型不一致立刻报错,而不是继续运行可能存在问题的程序

类型擦除(Type Erasure)

我们知道,编译器会将泛型擦除,那怎么理解泛型擦除呢?是统一改成Object吗?

泛型擦除遵循以下规则:

  • 如果泛型参数无界,则编译器会将其替换为Object
  • 如果泛型参数有界,则编译器会将其替换为边界类型。
public class TypeErasureDemo {
    public <T> void forEach(Collection<T> collection) {}

    public <E extends String> void iter(Collection<E> collection) {}
}

使用javap命令查看 Class 文件信息:

class文件信息1
class文件信息2

通过 Class 文件信息可以看到:编译器将forEach方法的泛型替换为了Object,将iter方法的泛型替换为了String

泛型和方法重载(overload)

了解完泛型擦除规则之后,我们来看一下当泛型遇到方法重载,会遇到什么样的问题呢?

阅读如下代码:

// 第一组
public static void printArray(Object[] objs) {}

public static <T> void printArray(T[] objs) {}
// 第二组
public static void printArray(Object[] objs) {}

public static <T extends Person> void printArray(T[] objs) {}

上面两组方法是否都构成了重载呢?

  • 第一组:泛型会被擦除,也就是说,在运行时期,T[]其实就是Object[],因此第一组不构成重载。
  • 第二组:<T extends Person>表明接收的方法是Person的子类,构成重载。

使用 ResolvableType 解析泛型

Spring 框架中提供了org.springframework.core.ResolvableType来优雅解析泛型。

一个简单的使用示例如下:

public class ResolveTypeDemo {

    private static final List<String> strList = Lists.newArrayList("a");

    public <T extends CharSequence> void exchange(T obj) {}

    public static void resolveFieldType() throws Exception {
        Field field = ReflectionUtils.findField(ResolveTypeDemo.class, "strList");
        ResolvableType resolvableType = ResolvableType.forField(field);
        // class java.lang.String
        System.out.println(resolvableType.getGeneric(0).resolve());
    }

    public static void resolveMethodParameterType() throws Exception {
        Parameter[] parameters = ReflectionUtils.findMethod(ResolveTypeDemo.class, "exchange", CharSequence.class).getParameters();
        ResolvableType resolvableType = ResolvableType.forMethodParameter(MethodParameter.forParameter(parameters[0]));
        // interface java.lang.CharSequence
        System.out.println(resolvableType.resolve());
    }

    public static void resolveInstanceType() throws Exception {
        PayloadApplicationEvent<String> instance = new PayloadApplicationEvent<>(new Object(), "hi");
        ResolvableType resolvableTypeForInstance = ResolvableType.forInstance(instance);
        // class java.lang.String
        System.out.println(resolvableTypeForInstance.as(PayloadApplicationEvent.class).getGeneric().resolve());
    }
}

泛型和 JSON 反序列化

最近看到这样一个代码,使用 Jackson 将 JSON 转化为 Map。

public class JsonToMapDemo {

    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

    public static <K, V> Map<K, V> toMap(String json) throws JsonProcessingException {
        return (Map) OBJECT_MAPPER.readValue(json, new TypeReference<Map<K, V>>() {
        });
    }

    public static void main(String[] args) throws JsonProcessingException {
        // {"1":{"id":1}}
        String json = "{\"1\":{\"id\":1}}";
        Map<Integer, User> userIdMap = OBJECT_MAPPER.readValue(json, new TypeReference<Map<Integer, User>>() {
        });
        userIdMap.forEach((integer, user) -> {
            System.out.println(user.getId());
        });

    }

    @Data
    public static class User implements Serializable {
        private static final long serialVersionUID = 8817514749356118922L;
        private int id;
    }
}

运行 main 方法,代码虽然正常结束。但是这个代码其实是有问题的,有什么问题呢?一起来看如下代码:

public static void main(String[] args) {
    // {"1":{"id":1}}
    String json = "{\"1\":{\"id\":1}}";
    Map<Integer, User> userIdMap = toMap(json);
    userIdMap.forEach((integer, user) -> {
        // 出处代码会报错
        // Exception in thread "main" java.lang.ClassCastException:
        // java.lang.String cannot be cast to java.lang.Integer
        System.out.println(user.getId());
    });
}

为什么会报ClassCastException呢?让我们来 Debug 一探究竟。

debug

通过 Debug 可以发现:Map<Integer, User> userIdMap对象的 key 其实是String类型,而 value 是一个LinkedHashMap。这很好理解,上述代码这个写法,根本不知道 K,V 是什么。正确写法如下:

public static void main(String[] args) throws JsonProcessingException {
    // {"1":{"id":1}}
    String json = "{\"1\":{\"id\":1}}";
    Map<Integer, User> userIdMap = OBJECT_MAPPER.readValue(json, new TypeReference<Map<Integer, User>>() {
    });
    userIdMap.forEach((integer, user) -> {
      System.out.println(user.getId());
    });
}
作者:程序员小黑
来源:https://juejin.im/post/5e16b899f265da5d6443e78c

版权声明:文末如注明作者和来源,则表示本文系转载,版权为原作者所有 | 本文如有侵权,请及时联系,承诺在收到消息后第一时间删除 | 如转载本文,请注明原文链接。
喜欢 (1)