首页 > > 程序设计 > Java技术 >

你对Java泛型的理解够深入吗？

2020-01-09 16:05:06来源：博客园 阅读 ()

新老客户大回馈,云服务器低至5折

你对Java泛型的理解够深入吗？

泛型

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

在没有泛型之前：

/**
 * 迭代 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赋值成功，objList和strList变量引用的是同一个地址。那会有什么问题呢？

如果此时，往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。虽然String是Object的子类，但是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());
  });
}

欢迎关注微信公众号：Coder小黑

Coder小黑


原文链接:https://www.cnblogs.com/coderxiaohei/p/12170983.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：Mdb文件工具类，UCanAccess使用，Access数据库操作

下一篇：聊聊spring之贯穿全局的重要对象BeanDefinition

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签