Java 泛型
泛型是通用设计上必不可少的元素,所以真正理解与正确使用泛型,是一门必修课!

大纲

2021-05-07-09-09-24-726932.png

基础

因为本文重实践,而且面对的是Java开发人员群体,大家对泛型都有基础,所以泛型基础这块会快速过,帮助大家回忆下即可,后面主要的则重点是通配符

编译期与运行期

编译期是指把源码交给编译器编译成计算机可执行文件的过程,运行期是指把编译后的文件交给计算机执行,直到程序结束。
在Java中就是把.java文件编译成.class文件,再把编译后的文件交给J V M加载执行,如下图
2021-05-07-09-09-24-801950.png

泛型

泛型又叫“参数化类型”,这么抽象的专业词汇不好理解,阿星就用大白话的形式来解释。
人是铁,饭是刚,吃饭是刚需,要吃饭自然就少不了碗筷,但是没有规定碗只能盛饭,除了盛饭它还能盛汤、盛菜,制造者只造这个碗,不关心碗盛什么,具体要盛什么由使用者来决定,这就是泛型的概念。
泛型就是在定义类、接口、方法的时候指定某一种特定类型(碗),让类、接口、方法的使用者来决定具体用哪一种类型的参数(盛的东西)。
Java的泛型是在1.5引入的,只在编译期做泛型检查,运行期泛型就会消失,把这称为“泛型擦除”,最终类型都会变成Object
在没有泛型之前,从集合中读取到的每一个对象都必须进行类型转换,如果不小心插入了错误的类型对象,在运行时的转换处理就会出错,有了泛型后,你可以告诉编译器每个集合接收的对象类型是什么,编译器在编译期就会做类型检查,告知是否插入了错误类型的对象,使得程序更加安全,也更加清楚。
最后插一句,泛型擦除与原生态类型(List就是原生态,List<T>非原生态)是为了照顾1.5以前设计上的缺陷,为兼容非泛型代码,所作出的折中策略,所以不推荐使用原生态类型,如果使用了原生态类型,就失去了泛型在安全性与描述性方面的优势。

泛型类

2021-05-07-09-09-24-848373.png
类上定义泛型,作用于类的成员变量与函数,代码实例如下

  1. public class GenericClass<T>{
  2. //成员变量
  3. private T t;
  4. public void function(T t){
  5. }
  6. public T functionTwo(T t){
  7. //注意,这个不是泛型方法!!!
  8. return t;
  9. }
  10. }

泛型接口

接口上定义泛型,作用于函数,代码实例如下

  1. public interface GenericInterface<T> {
  2. public T get();
  3. public void set(T t);
  4. public T delete(T t);
  5. default T defaultFunction(T t){
  6. return t;
  7. }
  8. }

泛型函数

2021-05-07-09-09-24-974472.png
函数返回类型旁加上泛型,作用于函数,代码实例如下

  1. public class GenericFunction {
  2. public <T> void function(T t) {
  3. }
  4. public <T> T functionTwo(T t) {
  5. return t;
  6. }
  7. public <T> String functionThree(T t) {
  8. return "";
  9. }
  10. }

通配符

通配符是为了让Java泛型支持范围限定,这样使得泛型的灵活性提升,同时也让通用性设计有了更多的空间。

  • <?>:无界通配符,即类型不确定,任意类型
  • <? extends T>:上边界通配符,即?是继承自T的任意子类型,遵守只读不写
  • <? super T>:下边界通配符,即?T的任意父类型,遵守只写不读

通配符限定的范围是体现在确认“参数化类型”的时候,而不是“参数化类型”填充后」,可能这句话不太好理解,来看看下面的代码

  1. /**
  2. * 1.创建泛型为Number的List类,Integer、Double、Long等都是Number的子类
  3. * new ArrayList<>() 等价于 new ArrayList<Number>()
  4. */
  5. List<Number> numberList = new ArrayList<Number>();
  6. /**
  7. * 2.添加不同子类
  8. */
  9. numberList.add(1);//添加Integer类型
  10. numberList.add(0.5);//添加Double类型
  11. numberList.add(10000L);//添加Long类型
  12. /**
  13. * 3.创建泛型为Number的List类,Integer、Double、Long等都是Number的子类
  14. * 引用是泛型类别是Number,但具体实现指定的泛型是Integer
  15. */
  16. List<Number> numberListTwo = new ArrayList<Integer>();//err 异常编译不通过
  17. /**
  18. * 4.创建泛型为Integer的List类,把该对象的引用地址指向泛型为Number的List
  19. */
  20. List<Integer> integerList = new ArrayList<Integer>();
  21. List<Number> numberListThree = integerList;//err 异常编译不通过
  • 第一步:创建一个泛型为NumberList,编译器检查泛型类别是否一致,一致编译通过(确认参数化类型)
  • 第二步:泛型Number已经填充完毕,调用add函数,此时add入参泛型T已经填充为Numberadd可入参Number或其子类
  • 第三步:又创建一个泛型为NumberList,编译器检查泛型类别是否一致,不一致编译失败,提示错误(确认参数化类型)
  • 第四步:其实与第三步一样,只是做了一个间接的引用(确认参数化类型)

如果要解决上面的编译不通过问题,就需要使用通配符,代码如下

  1. /**
  2. * 1.上边界通配符,Number与Number子类
  3. */
  4. List<? extends Number> numberListFour = new ArrayList<Number>();
  5. numberListFour = new ArrayList<Integer>();
  6. numberListFour = new ArrayList<Double>();
  7. numberListFour = new ArrayList<Long>();
  8. /**
  9. * 2.下边界通配符,Integer与Integer父类
  10. */
  11. List<? super Integer> integerList = new ArrayList<Integer>();
  12. integerList = new ArrayList<Number>();
  13. integerList = new ArrayList<Object>();
  14. /**
  15. * 3. 无界通配符,类型不确定,任意类型
  16. */
  17. List<?> list = new ArrayList<Integer>();
  18. list = new ArrayList<Number>();
  19. list = new ArrayList<Object>();
  20. list = new ArrayList<String>();

最后再来说上边界通配符只读不写,下边界通配符只写不读到底是什么意思,用最简单的话来说

  • <? extends T>上边界通配符不作为函数入参,只作为函数返回类型,比如List<? extends T>的使用add函数会编译不通过,get函数则没问题
  • <? super T>下边界通配符不作为函数返回类型,只作为函数入参,比如List<? super T>add函数正常调用,get函数也没问题,但只会返回Object,所以意义不大

大家只需要记住上面的规则即可,如果想知道为什么这样设计,可以去了解下P E C S (producer-extends,consumer-super)原则

最佳实践

无限通配符场景

使用泛型,类型参数不确定并且不关心实际的类型参数,就可以使用<?>,像下面的代码

  1. /**
  2. * 获取集合长度
  3. */
  4. public static <T> int size(Collection<T> list){
  5. return list.size();
  6. }
  7. /**
  8. * 获取集合长度-2
  9. */
  10. public static int sizeTwo(Collection<?> list){
  11. return list.size();
  12. }
  13. /**
  14. * 获取任意Set两个集合交集数量
  15. */
  16. public static <T,T2> int beMixedSum(Set<T> s1,Set<T2> s2){
  17. int i = 0;
  18. for (T t : s1) {
  19. if (s2.contains(t)) {
  20. i++;
  21. }
  22. }
  23. return i;
  24. }
  25. /**
  26. * 获取任意两个Set集合交集数量-2
  27. */
  28. public static int beMixedSumTwo(Set<?> s1,Set<?> s2){
  29. int i = 0;
  30. for (Object o : s1) {
  31. if (s2.contains(o)) {
  32. i++;
  33. }
  34. }
  35. return i;
  36. }

sizesizeTwo这两个函数都可以正常使用,但是站在设计的角度,sizeTwo会更合适,函数的目标是返回任意集合的长度,入参采用<T><?>都可以接收,但是函数本身并不关心你是什么类型参数,仅仅只要返回长度即可,所以采用<?>
beMixedSumbeMixedSumTwo这两个函数比较,道理同上面一样,beMixedSumTwo会更合适,函数的目标是返回两个任意Set集合的交集数量,beMixedSum函数虽然内部有使用到<T>,但是意义不大,因为contains入参是Object,函数本身并不关心你是什么类型参数,所以采用<?>
忘了补充另一个场景,就是原生态类型,上述代码使用原生态类型函数使用也没问题,但是强烈不推荐,因为使用原生态就丢失了泛型带来的安全性与描述性!!!

上下边界通配符场景

首先泛型是不变的,换句话说List<Object> != List<String>,有时候需要更多灵活性,就可以通过上下边界通配符来做提升。

  1. /**
  2. * 集合工具类
  3. */
  4. public class CollectionUtils<T>{
  5. /**
  6. * 复制集合-泛型
  7. */
  8. public List<T> listCopy(Collection<T> collection){
  9. List<T> newCollection = new ArrayList<>();
  10. for (T t : collection) {
  11. newCollection.add(t);
  12. }
  13. return newCollection;
  14. }
  15. }

上面声明了一个CollectionUtils类,拥有listCopy方法,传入任意一个集合返回新的集合,看似没有什么问题,也很灵活,那再看看下面这段代码。

  1. public static void main(String[] agrs){
  2. CollectionUtils<Number> collectionUtils = new CollectionUtils<>();
  3. List<Number> list = new ArrayList<>();
  4. //list.add....
  5. List<Integer> listTwo = new ArrayList<>();
  6. //listTwo.add....
  7. List<Double> listThree = new ArrayList<>();
  8. //listThree.add....
  9. List<Number> list1 = collectionUtils.listCopy(list);
  10. list1 = collectionUtils.listCopy(listTwo);//err 编译异常
  11. list1 = collectionUtils.listCopy(listThree);//err 编译异常
  12. }

创建CollectionUtils类,泛型的类型参数为NumberlistCopy函数入参的泛型填充为Number,此时listCopy只支持泛型为NumberList,如果要让它同时支持泛型为Number子类的List,就需要使用上边界通配符,再追加一个方法

  1. /**
  2. * 集合工具
  3. */
  4. public class CollectionUtils<T>{
  5. /**
  6. * 复制集合-泛型
  7. */
  8. public List<T> listCopy(Collection<T> collection){
  9. List<T> newCollection = new ArrayList<>();
  10. for (T t : collection) {
  11. newCollection.add(t);
  12. }
  13. return newCollection;
  14. }
  15. /**
  16. * 复制集合-上边界通配符
  17. */
  18. public List<T> listCopyTwo(Collection<? extends T> collection){
  19. List<T> newCollection = new ArrayList<>();
  20. for (T t : collection) {
  21. newCollection.add(t);
  22. }
  23. return newCollection;
  24. }
  25. }
  26. public static void main(String[] agrs){
  27. CollectionUtils<Number> collectionUtils = new CollectionUtils<>();
  28. List<Number> list = new ArrayList<>();
  29. //list.add....
  30. List<Integer> listTwo = new ArrayList<>();
  31. //listTwo.add....
  32. List<Double> listThree = new ArrayList<>();
  33. //listThree.add....
  34. List<Number> list1 = collectionUtils.listCopyTwo(list);
  35. list1 = collectionUtils.listCopyTwo(listTwo);
  36. list1 = collectionUtils.listCopyTwo(listThree);
  37. }

现在使用listCopyTwo就没有问题,listCopyTwo对比listCopy它的适用范围更广泛也更灵活,listCopy能做的listCopyTwo能做,listCopyTwo能做的listCopy就不一定能做了,除此之外,细心的小伙伴肯定发现了,使用上边界通配符的collection在函数内只使用到了读操作,遵循了只读不写原则。
看完了上边界通配符,再来看看下边界通配符,依然是复制方法

  1. /**
  2. * 儿子
  3. */
  4. public class Son extends Father{}
  5. /**
  6. * 父亲
  7. */
  8. public class Father extends Grandpa{}
  9. /**
  10. * 爷爷
  11. */
  12. public class Grandpa {}
  13. /**
  14. * 集合工具
  15. */
  16. public class CollectionUtils<T>{
  17. /**
  18. * 复制集合-泛型
  19. * target目标 src来源
  20. */
  21. public void copy(List<T> target,List<T> src){
  22. if (src.size() > target.size()){
  23. for (int i = 0; i < src.size(); i++) {
  24. target.set(i,src.get(i));
  25. }
  26. }
  27. }
  28. }

定义了3个类,分别是Son儿子、Father父亲、Grandpa爷爷,它们是继承关系,作为集合元素,还声明了一个CollectionUtils类,拥有copy方法,传入两个集合,目标集合与来源集合,把来源集合元素复制到目标集合中,再看看下面这段代码

  1. public static void main(String[] agrs){
  2. CollectionUtils<Father> collectionUtils = new CollectionUtils<>();
  3. List<Father> fatherTargets = new ArrayList<>();
  4. List<Father> fatherSources = new ArrayList<>();
  5. //fatherSources.add...
  6. collectionUtils.copy(fatherTargets,fatherSources);
  7. //子类复制到父类
  8. List<Son> sonSources = new ArrayList<>();
  9. //sonSources.add...
  10. collectionUtils.copy(fatherTargets,sonSources);//err 编译异常
  11. }

创建CollectionUtils类,泛型的类型参数为Father父亲,copy函数入参的泛型填充为Father,此时copy只支持泛型为FatherList,也就说,只支持泛型的类型参数为Father之间的复制,如果想支持把子类复制到父类要怎么做,先分析下copy函数,copy函数的入参src在函数内部只涉及到了get函数,即读操作(泛型只作为get函数返回类型),符合只读不写原则,可以采用上边界通配符,调整代码如下

  1. /**
  2. * 集合工具
  3. */
  4. public class CollectionUtils<T>{
  5. /**
  6. * 复制集合-泛型
  7. * target目标 src来源
  8. */
  9. public void copy(List<T> target,List<? extends T> src){
  10. if (src.size() > target.size()){
  11. for (int i = 0; i < src.size(); i++) {
  12. target.set(i,src.get(i));
  13. }
  14. }
  15. }
  16. }
  17. public static void main(String[] agrs){
  18. CollectionUtils<Father> collectionUtils = new CollectionUtils<>();
  19. List<Father> fatherTargets = new ArrayList<>();
  20. List<Father> fatherSources = new ArrayList<>();
  21. //fatherSources.add...
  22. collectionUtils.copy(fatherTargets,fatherSources);
  23. //子类复制到父类
  24. List<Son> sonSources = new ArrayList<>();
  25. //sonSources.add...
  26. collectionUtils.copy(fatherTargets,sonSources);
  27. //把子类复制到父类的父类
  28. List<Grandpa> grandpaTargets = new ArrayList<>();
  29. collectionUtils.copy(grandpaTargets,sonSources);//err 编译异常
  30. }

src入参调整为上边界通配符后,copy函数传入List<Son> sonSources就没问题了,此时的copy函数相较之前的更加灵活了,支持同类与父子类复制,接着又发现了一个问题,目前能复制到上一级父类,如果是多级父类,还无法支持,继续分析copy函数,copy函数的入参target在函数内部只涉及到了add函数,即写操作(泛型只作为add函数入参),符合只写不读原则,可以采用下边界通配符,调整代码如下

  1. /**
  2. * 集合工具
  3. */
  4. public class CollectionUtils<T>{
  5. /**
  6. * 复制集合-泛型
  7. * target目标 src来源
  8. */
  9. public void copy(List<? super T> target,List<? extends T> src){
  10. if (src.size() > target.size()){
  11. for (int i = 0; i < src.size(); i++) {
  12. target.set(i,src.get(i));
  13. }
  14. }
  15. }
  16. }
  17. public static void main(String[] agrs){
  18. CollectionUtils<Father> collectionUtils = new CollectionUtils<>();
  19. List<Father> fatherTargets = new ArrayList<>();
  20. List<Father> fatherSources = new ArrayList<>();
  21. //fatherSources.add...
  22. collectionUtils.copy(fatherTargets,fatherSources);
  23. //子类复制到父类
  24. List<Son> sonSources = new ArrayList<>();
  25. //sonSources.add...
  26. collectionUtils.copy(fatherTargets,sonSources);
  27. //把子类复制到父类的父类
  28. List<Grandpa> grandpaTargets = new ArrayList<>();
  29. collectionUtils.copy(grandpaTargets,sonSources);
  30. }

copy函数终于是完善了,可以说现在是真正支持父子类复制,不难发现copy函数的设计还是遵循通配符原则的,target作为目标集合,只做写入,符合只写不读原则,采用了下边界通配符,src作为来源集合,只做读取,符合只读不写原则,采用了上边界通配符,最后设计出来的copy函数,它的灵活性与适用范围是远超<T>方式设计的。
最后总结一下,什么时候用通配符,如果参数泛型类即要读也要写,那么就不推荐使用,使用正常的泛型即可,如果参数泛型类只读或写,就可以根据原则采用对应的上下边界,是不是十分简单,最后再说一次读写的含义,这块确实很容易晕

  • 读:所谓读是指参数泛型类,泛型只作为该参数类的函数返回类型,那这个函数就是读,List作为参数泛型类,它的get函数就是读
  • 写:所谓写是指参数泛型类,泛型只作为该参数类的函数入参,那这个函数就是写,List作为参数泛型类,它的add函数就是读

可以思考下StreamforEach函数与map函数的设计,在Java1.8 Stream中是大量用到了通配符设计

  1. /**
  2. * 下边界通配符
  3. */
  4. void forEach(Consumer<? super T> action);
  5. public interface Consumer<T> {
  6. //写方法
  7. void accept(T t);
  8. }
  1. /**
  2. * 上下边界通配符
  3. */
  4. <R> Stream<R> map(Function<? super T, ? extends R> mapper)
  5. public interface Function<T, R> {
  6. //读写方法,T只作为入参符合写,R只作为返回值,符合读
  7. R apply(T t);
  8. }
  1. //代码案例
  2. public static void main(String[] agrs) {
  3. List<Father> fatherList = new ArrayList<>();
  4. Consumer<? super Father> action = new Consumer<Father>() {
  5. @Override
  6. public void accept(Father father) {
  7. //执行father逻辑
  8. }
  9. };
  10. //下边界通配符向上转型
  11. Consumer<? super Father> actionTwo = new Consumer<Grandpa>() {
  12. @Override
  13. public void accept(Grandpa grandpa) {
  14. //执行grandpa逻辑
  15. }
  16. };
  17. Function<? super Father, ? extends Grandpa> mapper = new Function<Father, Grandpa>() {
  18. @Override
  19. public Grandpa apply(Father father) {
  20. //执行father逻辑后返回Grandpa
  21. return new Grandpa();
  22. }
  23. };
  24. //下边界通配符向上转型,上边界通配符向下转型
  25. Function<? super Father, ? extends Grandpa> mapperTwo = new Function<Grandpa, Son>() {
  26. @Override
  27. public Son apply(Grandpa grandpa) {
  28. //执行grandpa逻辑后,返回Son
  29. return new Son();
  30. }
  31. };
  32. fatherList.stream().forEach(action);
  33. fatherList.stream().forEach(actionTwo);
  34. fatherList.stream().map(mapper);
  35. fatherList.stream().map(mapperTwo);
  36. }

有限制泛型场景

有限制泛型很简单了,应用场景就是需要对泛型的参数类型做限制,就可以使用它,比如下面这段代码

  1. public class GenericClass<T extends Grandpa> {
  2. public void test(T t){
  3. //....
  4. }
  5. }
  6. public static void main(String[] agrs){
  7. GenericClass<Grandpa> grandpaGeneric = new GenericClass<>();
  8. grandpaGeneric.test(new Grandpa());
  9. grandpaGeneric.test(new Father());
  10. grandpaGeneric.test(new Son());
  11. GenericClass<Father> fatherGeneric = new GenericClass<>();
  12. fatherGeneric.test(new Father());
  13. fatherGeneric.test(new Son());
  14. GenericClass<Son> sonGeneric = new GenericClass<>();
  15. sonGeneric.test(new Son());
  16. GenericClass<Object> ObjectGeneric = new GenericClass<>();//err 编译异常
  17. }

GenericClass泛型参数化类型被限制为Grandpa或其子类,就这么简单,千万不要把有限制泛型与上边界通配符搞混了,这两个不是同一个东西(<T extends Grandpa> != <? extends Grandpa>),<T extends Grandpa>不需要遵循上边界通配符的原则,它就是简单的泛型参数化类型限制,而且没有super的写法。

递归泛型场景

在有限制泛型的基础上,又可以衍生出递归泛型,就是自身需要使用到自身,比如集合进行自定义元素大小比较的时候,通常会配合Comparable接口来完成,看看下面这段代码

  1. public class Person implements Comparable<Person> {
  2. private int age;
  3. public Person(int age) {
  4. this.age = age;
  5. }
  6. public int getAge() {
  7. return age;
  8. }
  9. @Override
  10. public int compareTo(Person o) {
  11. // 0代表相等 1代表大于 <0代表小于
  12. return this.age - o.age;
  13. }
  14. }
  15. /**
  16. * 集合工具
  17. */
  18. public class CollectionUtils{
  19. /**
  20. * 获取集合最大值
  21. */
  22. public static <E extends Comparable<E>> E max(List<E> list){
  23. E result = null;
  24. for (E e : list) {
  25. if (result == null || e.compareTo(result) > 0){
  26. result = e;
  27. }
  28. }
  29. return result;
  30. }
  31. }
  32. public static void main(String[] agrs){
  33. List<Person> personList = new ArrayList<>();
  34. personList.add(new Person(12));
  35. personList.add(new Person(19));
  36. personList.add(new Person(20));
  37. personList.add(new Person(5));
  38. personList.add(new Person(18));
  39. //返回年龄最大的Person元素
  40. Person max = CollectionUtils.max(personList);
  41. }

重点关注max泛型函数,max泛型函数的目标是返回集合最大的元素,内部比较元素大小,取最大值返回,也就说需要和同类型元素做比较,<E extends Comparable<E>>含义是,泛型E必须是Comparable或其子类/实现类,因为比较元素是同类型,所以Comparable泛型也是E,最终接收的List泛型参数化类型必须实现了Comparable接口,并且Comparable接口填充的泛型也是该参数化类型,就像上述代码一样。