来源:
Java 泛型(generics)是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制,该机制允许开发者在编译时检测到非法的类型。
泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。
在未有泛型之前,是在使用强制转换,但使用强制转换的前提是必须开发人员已知,对于强制类型转换错误的情况,编译器可能不提示错误,在运行的时候才出现异常,这是本身就是一个安全隐患。
好处:
泛型在编译的时候能够检查类型安全,并且所有的强制转换都是自动和隐式的。
泛型中通配符
常用的 T,E,K,V,?
本质上这些个都是通配符,没区别,只不过是编码时的一种约定俗成的东西。
通常情况下,T,E,K,V,?是这样约定的:
?表示不确定的 java 类型
T (type) 表示具体的一个 java 类型
K V (key value) 分别代表 java 键值中的 Key Value
E (element) 代表 Element
? 无界通配符
先从一个小例子看起,原文在 这里 。(https://codeday.me/bug/20180113/116421.html)
我有一个父类 Animal 和几个子类,如狗、猫等,现在我需要一个动物的列表,我的第一个想法是像这样的:
ListlistAnimals
但是老板的想法确实这样的:
List extends Animal> listAnimals`
为什么要使用通配符而不是简单的泛型呢?通配符其实在声明局部变量时是没有什么意义的,但是当你为一个方法声明一个参数时,它是非常重要的。
static int countLegs (List extends Animal > animals ) {
int retVal = 0;
for ( Animal animal : animals )
{
retVal += animal.countLegs();
}
return retVal;
}
static int countLegs1 (List< Animal > animals ){
int retVal = 0;
for ( Animal animal : animals )
{
retVal += animal.countLegs();
}
return retVal;
}
public static void main(String[] args) {
List dogs = new ArrayList<>();
// 不会报错
countLegs( dogs );
// 报错
countLegs1(dogs);
}
当调用 countLegs1 时,就会飘红,提示的错误信息如下:
所以,对于不确定或者不关心实际要操作的类型,可以使用无限制通配符(尖括号里一个问号,即 ),表示可以持有任何类型。像 countLegs 方法中,限定了上届,但是不关心具体类型是什么,所以对于传入的 Animal 的所有子类都可以支持,并且不会报错。而 countLegs1 就不行。
上界通配符
上届:用 extends 关键字声明,表示参数化的类型可能是所指定的类型,或者是此类型的子类。
在类型参数中使用 extends 表示这个泛型中的参数必须是 E 或者 E 的子类,这样有两个好处:
如果传入的类型不是 E 或者 E 的子类,编译不成功
泛型中可以使用 E 的方法,要不然还得强转成 E 才能使用
private E test(K arg1, E arg2){
E result = arg2;
arg2.compareTo(arg1);
//.....
return result;
}
类型参数列表中如果有多个类型参数上限,用逗号分开
下界通配符
下界: 用 super 进行声明,表示参数化的类型可能是所指定的类型,或者是此类型的父类型,直至 Object
在类型参数中使用 super 表示这个泛型中的参数必须是 E 或者 E 的父类。
private void test(List super T> dst, List src){
for (T t : src) {
dst.add(t);
}
}
public static void main(String[] args) {
List dogs = new ArrayList<>();
List animals = new ArrayList<>();`
new Test3().test(animals,dogs);
}
// Dog 是 Animal 的子类
class Dog extends Animal {
}
dst 类型 “大于等于” src 的类型,这里的 “大于等于” 是指 dst 表示的范围比 src 要大,因此装得下 dst 的容器也就能装 src 。
?和 T 的区别
?和 T 都表示不确定的类型,区别在于我们可以对 T 进行操作,但是对 ?不行,比如如下这种 :
// 可以
T t = operate();
// 不可以
? car = operate();
简单总结下:
T 是一个 确定的 类型,通常用于泛型类和泛型方法的定义,?是一个 不确定 的类型,通常用于泛型方法的调用代码和形参,不能用于定义类和泛型方法。
区别 1:通过 T 来 确保 泛型参数的一致性
// 通过 T 来 确保 泛型参数的一致性
public void
test(List dest, List src)
//通配符是 不确定的,所以这个方法不能保证两个 List 具有相同的元素类型
public void
test(List extends Number> dest, List extends Number> src)
像下面的代码中,约定的 T 是 Number 的子类才可以,但是申明时是用的 String ,所以就会飘红报错。
不能保证两个 List 具有相同的元素类型的情况
GlmapperGeneric glmapperGeneric = new GlmapperGeneric<>();
List dest = new ArrayList<>();
List src = new ArrayList<>();
glmapperGeneric.testNon(dest,src);
上面的代码在编译器并不会报错,但是当进入到 testNon 方法内部操作时(比如赋值),对于 dest 和 src 而言,就还是需要进行类型转换。
区别 2:类型参数可以多重限定而通配符不行
使用 & 符号设定多重边界(Multi Bounds),指定泛型类型 T 必须是 MultiLimitInterfaceA 和 MultiLimitInterfaceB 的共有子类型,此时变量 t 就具有了所有限定的方法和属性。对于通配符来说,因为它不是一个确定的类型,所以不能进行多重限定。
区别 3:通配符可以使用超类限定而类型参数不行
类型参数 T 只具有 一种 类型限定方式:
`T extends A
但是通配符 ? 可以进行 两种限定:
? extends A
? super A
Class 和 Class>`区别
前面介绍了 ?和 T 的区别,那么对于, Class
Class
最常见的是在反射场景下的使用,这里以用一段发射的代码来说明下。
// 通过反射的方式生成 multiLimit
// 对象,这里比较明显的是,我们需要使用强制类型转换
MultiLimit multiLimit = (MultiLimit)
Class.forName("com.glmapper.bridge.boot.generic.MultiLimit").newInstance();
对于上述代码,在运行期,如果反射的类型不是 MultiLimit 类,那么一定会报 java.lang.ClassCastException 错误。
对于这种情况,则可以使用下面的代码来代替,使得在在编译期就能直接 检查到类型的问题:
Class
在实例化的时候,T 要替换成具体类。 Class>
它是个通配泛型,? 可以代表任何类型,所以主要用于声明时的限制情况。比如,我们可以这样做申明:
// 可以
public Class> clazz;
// 不可以,因为 T 需要指定类型
public Class clazzT;
所以当不知道定声明什么类型的 Class 的时候可以定义一 个 Class。
那如果也想 publicClass
这样的话,就必须让当前的类也指定 T ,
public class Test3 {`
public Class> clazz;`
// 不会报错`
public Class clazzT;`
背后的原理
Java的泛型是伪泛型,这是因为Java在编译期间,所有的泛型信息都会被擦掉,这也就是通常所说类型擦除 。 更多关于类型擦除的问题,可以查看这篇文章:《Java泛型类型擦除以及类型擦除带来的问题》 。
类型擦除带来的局限性
类型擦除,是泛型能够与之前的 java 版本代码兼容共存的原因。但也因为类型擦除,它会抹掉很多继承相关的特性,这是它带来的局限性。
理解类型擦除有利于我们绕过开发当中可能遇到的雷区,同样理解类型擦除也能让我们绕过泛型本身的一些限制。比如
正常情况下,因为泛型的限制,编译器不让最后一行代码编译通过,因为类似不匹配,但是,基于对类型擦除的了解,利用反射,我们可以绕过这个限制。
public interface List extends Collection{ boolean add(E e);}
上面是 List 和其中的 add() 方法的源码定义。
因为 E 代表任意的类型,所以类型擦除时,add 方法其实等同于
boolean add(Object obj);
那么,利用反射,我们绕过编译器去调用 add 方法。
public class ToolTest {
public static void main(String[] args) {
List ls = new ArrayList<>();
ls.add(23);//
ls.add("text");
try {
Method method = ls.getClass().getDeclaredMethod("add",Object.class);
method.invoke(ls,"test");
method.invoke(ls,42.9f);
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
for ( Object o: ls){
System.out.println(o);
}
}
}
打印结果是:
23test42.9
可以看到,利用类型擦除的原理,用反射的手段就绕过了正常开发中编译器不允许的操作限制。
泛型中值得注意的地方
泛型类或者泛型方法中,不接受 8 种基本数据类型。
所以,你没有办法进行这样的编码。
List li = new ArrayList<>();List li = new ArrayList<>();
需要使用它们对应的包装类。
List li = new ArrayList<>();List li1 = new ArrayList<>();
对泛型方法的困惑
public T test(T t){ return null;}
有的同学可能对于连续的两个 T 感到困惑,其实
是为了说明类型参数,是声明,而后面的不带尖括号的 T 是方法的返回值类型。
你可以相像一下,如果 test() 这样被调用
test("123");
那么实际上相当于
public String test(String t);
Java 不能创建具体类型的泛型数组
这句话可能难以理解,代码说明。
List[] li2 = new ArrayList[];List li3 = new ArrayList[];
这两行代码是无法在编译器中编译通过的。原因还是类型擦除带来的影响。
List
和 List
在 jvm 中等同于List
,所有的类型信息都被擦除,程序也无法分辨一个数组中的元素类型具体是 List
类型还是 List
类型。
但是,
List>[] li3 = new ArrayList>[10];li3[1] = new ArrayList();List> v = li3[1];
借助于无限定通配符却可以,前面讲过 ?
代表未知类型,所以它涉及的操作都基本上与类型无关,因此 jvm 不需要针对它对类型作判断,因此它能编译通过,但是,只提供了数组中的元素因为通配符原因,它只能读,不能写。比如,上面的 v 这个局部变量,它只能进行 get() 操作,不能进行 add() 操作,这个在前面通配符的内容小节中已经讲过。
泛型中的陷阱
1、List ,List> 与 List
说实话,我敢保证很多人是不知道 List, List> 与 List
1、我们先来看看 List 与 List
很多可能觉得 List
这两种定义方法是一模一样的,然而他们是不一样的。看下面一段代码
List t1 = new ArrayList<>();
// 编译通过
List t2 = t1;
//编译失败
List t3 = t1;
t1 可以赋给 t2, 但是 t1 不能赋给 t3,会抛出如下异常
从这里可以看出
List list;与List
是有区别的,List >变量可以接受任何泛型的变量,而 List
2、我们在看看 Lis> 有什么需要注意的地方:
看下面一段代码:
List t1 = new ArrayList<>();
List> t2 = t1;
// 编译通过
t2.remove(0);
t2.clear();
// 编译不通过
t2.add(new Object());
List> 是一个泛型,在没有赋值之前,是可以接受任何集合的赋值的,我想这点大家都知道,但是请注意,赋值之后就不能往里面添加元素了,提示如下错误:
所以 List> 一般用来作为参数来接受外部的集合,或者返回一个不知道具体元素的集合。
List 与 List>, List
2、 extends T> 与 super T>你真的懂吗?
我们知道泛型 List
为了能够放置多种类型,于是有了 extend T> 与 super T>,下面先说一些你可能原本就知道的知识:
1、对于 extends T> a,a 这个变量可以接受 T 及其 T 子类的集合,上界为 T,并且从 a 取出来的类型都会被强制转换为 T。重点看下面一个例子:
注意:我们先约定 Cat(猫) 继承自 Animal(动物),RedCat(黑猫) 继承自 Cat
List animals = new ArrayList<>();
List cats = new ArrayList<>();
List redCats = new ArrayList<>();
// 可以通过编译
List extends Cat> extendsCat = redCats;
// 不能通过编译,因为只能接受 Cat 及其子类的集合
extendsCat = animals;
// 重点注意:下面三行都不能通过编译
extendsCat.add(new Animal());
extendsCat.add(new Cat());
extendsCat.add(new RedCat());
// 重点注意:可以通过编译
extendsCat.add(null);
注意, extends T>最需要注意的是,就是不能向里面添加除null之外的其他所有元素,这个和 List> 有点类似。
2、现在说说 super T>,它和 extends T> 有点相反。对于 super T> a,a 这个变量可以接受 T 及其 T 父类的集合,下界为 T,并且从 a 取出来的类型都会被强制转换为 Object。重点看下面一个例子:
List animals = new ArrayList<>();
List cats = new ArrayList<>();
List redCats = new ArrayList<>();
// 可以通过编译
List super Cat> superCat = animals;
// 不能通过编译,因为只能接受 Cat 及其父类的集合
superCat = redCats;
// 重点注意:不能通过编译,只能添加 Cat 及其 Cat 的子类
superCat.add(new Animal());
// 重点注意,可以通过编译
superCat.add(new Cat());
superCat.add(new RedCat());
superCat.add(null);
注意,<? super T>最需要注意的是,在虽然可以接受 T 及其父类的赋值,但是只能向里面添加 T 及其 T 的子类。
总结
1、List extends T> a ,可以把 a 及其 a 的子类赋给 a,从 a 里取的元素都会被强制转换为 T 类型,不过需要注意的是,不能向 a 添加任何除 null 外是元素。
2、List super T> a ,可以把 a 及其 a 的父类赋给 a,从 a 里取的元素都会被强制转换为 Object 类型,不过需要注意的是,可以向 a 添加元素,但添加的只能是 T 及其子类元素。
3、泛型与重载
我们先来看一道题,你觉得下面这道题能够编译通过吗?
public class GernerTypes {
public static void method(List list) {
System.out.println("List list");
}
public static void method(List list) {
System.out.println("List list");
}
}
答是编译不通过。
两个方法的参数不同,为什么会重载不通过呢?
实际上在 Java 的泛型中,泛型只存在于源码中,在编译后的字节码中,泛型已经被替换为原生类型了,并且在相应的地方插入了强制转换的代码。为了方便理解,可以看下面的一段代码例子:
// 源码
public static void main(String[] args) {
List list = new ArrayList<>();
list.add(1);
System.out.println(list.get(0));
}
编译之后泛型就不存在了,并且在相应的地方插入了强制转换的代码,编译之后,我们反编译的代码如下:
// 反编译之后的代码2 public static void main(String[] args) {
List list = new ArrayList();
list.add(1);
System.out.println((Integer)list.get(0));
}
这种 编译之后泛型就不存在了,并且在相应的地方插入了强制转换代码的机制我们也称之为擦除。
所以上面的两个方法,看似参数不一样,但是经过编译擦出之后,他们的参数就是一样的了,所以编译不通过。
4、数组与集合相互转换时需要注意的点
1、数组转集合
大家先看一个例子吧,
public static void main(String[] args) {
String[] arr = {"one", "two", "three"};
// 数组转换成集合
List list = Arrays.asList(arr);
// 向集合添加元素:编译正常,但运行时抛出了异常
list.add("four");
}
向集合添加元素抛出了如下异常:
问题来了,向集合添加元素为啥会抛出异常呢??
我们先来看一下 Arrays.asList(arr) 方法究竟返回了什么?
源码如下:
返回的明明是 ArrayList 啊,为啥就不能添加元素呢??
实际上,此 ArrayList 非彼 ArrayList,这个返回的 ArrayList 实际上是 Arrays 的一个内部类。该内部类也是十分简单,和真实的那个 ArrayList 没得比,部分源码如下:
而且这个假的 ArrayList 是直接 引用原数组的,不然你看它的构造器(第二条画线)
也就是说,ArrayList 内部是直接引用 arr 数组,你对 arr 数组进行改变,也会同时改变到 list 集合。
下面的代码证明这一点
public static void main(String[] args) {
String[] arr = {"one", "two", "three"};
// 数组转换成集合
List list = Arrays.asList(arr);
// 修改 arr
arr[0] = "0";
//打印看看
System.out.println(list.get(0));
}
打印结果是 “0”。
所以,我们向 list 添加元素肯定失败,因为 arr 数组的长度了 3 ,本来就有 3 个元素了,你在向里面添加第四个元素,肯定是不行的。
所以,在把数组转换为集合的过程中,需要特别注意。
建议大家这样转换比较安全
List list = new ArrayList<>(Arrays.asList(arr));
2、集合转数组
集合转换为数组相对比较不苛刻,我就不拉很多源码来进行分析了,我只简单说下几个需要注意的地方。例如对于下面这个转换:
// 集合大小为 size
List list = new ArrayList<>();
// 长度为 n 的数组
String[] arr = new String[n];
// 进行转换
list.toArray(arr);
1、如果数组长度比集合小:由于 arr 的长度不够,所以集合里的元素不会赋给 arr,而且自己再重新创建一个新数组反回去。
2、如果数组长度不小于集合:此时 arr 的长度够了,所以集合里的元素直接复制给 arr 数组,不会重新创建一个新的元素。
一览源码:
public T[] toArray(T[] a) {
if (a.length < size)
// 重新创建一个数组来返回去
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
// 长度够的话直接复制给 a
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}