Java泛型的些许知识

来源:

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 listAnimals`

为什么要使用通配符而不是简单的泛型呢?通配符其实在声明局部变量时是没有什么意义的,但是当你为一个方法声明一个参数时,它是非常重要的。

static  int countLegs (List 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 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 的区别

image

?和 T 都表示不确定的类型,区别在于我们可以对 T 进行操作,但是对 ?不行,比如如下这种 :

// 可以
T t = operate();
// 不可以
? car = operate();

简单总结下:

T 是一个 确定的 类型,通常用于泛型类和泛型方法的定义,?是一个 不确定 的类型,通常用于泛型方法的调用代码和形参,不能用于定义类和泛型方法。

区别 1:通过 T 来 确保 泛型参数的一致性

// 通过 T 来 确保 泛型参数的一致性
public    void
 test(List dest,  List src)
//通配符是 不确定的,所以这个方法不能保证两个 List 具有相同的元素类型
public  void
test(List dest,  List src)

像下面的代码中,约定的 T 是 Number 的子类才可以,但是申明时是用的 String ,所以就会飘红报错。

image

不能保证两个 List 具有相同的元素类型的情况

GlmapperGeneric glmapperGeneric =  new  GlmapperGeneric<>();
List dest =  new  ArrayList<>();
List src =  new  ArrayList<>();
glmapperGeneric.testNon(dest,src);

上面的代码在编译器并不会报错,但是当进入到 testNon 方法内部操作时(比如赋值),对于 dest 和 src 而言,就还是需要进行类型转换。

区别 2:类型参数可以多重限定而通配符不行

image

使用 & 符号设定多重边界(Multi Bounds),指定泛型类型 T 必须是 MultiLimitInterfaceA 和 MultiLimitInterfaceB 的共有子类型,此时变量 t 就具有了所有限定的方法和属性。对于通配符来说,因为它不是一个确定的类型,所以不能进行多重限定。

区别 3:通配符可以使用超类限定而类型参数不行

类型参数 T 只具有 一种 类型限定方式:

`T extends A

但是通配符 ? 可以进行 两种限定:

?  extends A

?  super A

Class 和 Class`区别

前面介绍了 ?和 T 的区别,那么对于, Class 又有什么区别呢?
Class 和 Class

最常见的是在反射场景下的使用,这里以用一段发射的代码来说明下。

// 通过反射的方式生成  multiLimit
// 对象,这里比较明显的是,我们需要使用强制类型转换
MultiLimit multiLimit =  (MultiLimit)
Class.forName("com.glmapper.bridge.boot.generic.MultiLimit").newInstance();

对于上述代码,在运行期,如果反射的类型不是 MultiLimit 类,那么一定会报 java.lang.ClassCastException 错误。

对于这种情况,则可以使用下面的代码来代替,使得在在编译期就能直接 检查到类型的问题:

image

Class 在实例化的时候,T 要替换成具体类。 Class 它是个通配泛型,? 可以代表任何类型,所以主要用于声明时的限制情况。比如,我们可以这样做申明:

// 可以
public  Class clazz;
// 不可以,因为 T 需要指定类型
public  Class clazzT;

所以当不知道定声明什么类型的 Class 的时候可以定义一 个 Class。

image

那如果也想 publicClassclazzT; 这样的话,就必须让当前的类也指定 T ,

public  class  Test3  {`
public  Class clazz;`
// 不会报错`
public  Class clazzT;`

背后的原理

Java的泛型是伪泛型,这是因为Java在编译期间,所有的泛型信息都会被擦掉,这也就是通常所说类型擦除 。 更多关于类型擦除的问题,可以查看这篇文章:《Java泛型类型擦除以及类型擦除带来的问题》 。

类型擦除带来的局限性

类型擦除,是泛型能够与之前的 java 版本代码兼容共存的原因。但也因为类型擦除,它会抹掉很多继承相关的特性,这是它带来的局限性。

理解类型擦除有利于我们绕过开发当中可能遇到的雷区,同样理解类型擦除也能让我们绕过泛型本身的一些限制。比如

image

正常情况下,因为泛型的限制,编译器不让最后一行代码编译通过,因为类似不匹配,但是,基于对类型擦除的了解,利用反射,我们可以绕过这个限制。

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[];

这两行代码是无法在编译器中编译通过的。原因还是类型擦除带来的影响。

ListList 在 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 是一样的,例如很多人认为
List list;与List list;

这两种定义方法是一模一样的,然而他们是不一样的。看下面一段代码

    List t1 = new ArrayList<>();
    // 编译通过
    List t2 = t1;
    //编译失败
    List t3 = t1;
 
 

t1 可以赋给 t2, 但是 t1 不能赋给 t3,会抛出如下异常

image

从这里可以看出

List list;与List list;

是有区别的,List 变量可以接受任何泛型的变量,而 List则不可以。

2、我们在看看 Lis 有什么需要注意的地方:

看下面一段代码:

  List t1 = new ArrayList<>();
  List t2 = t1;
   // 编译通过
  t2.remove(0);
  t2.clear();
  // 编译不通过
  t2.add(new Object());
 
 

List 是一个泛型,在没有赋值之前,是可以接受任何集合的赋值的,我想这点大家都知道,但是请注意,赋值之后就不能往里面添加元素了,提示如下错误:

image

所以 List 一般用来作为参数来接受外部的集合,或者返回一个不知道具体元素的集合。

List 与 List, List 的细微区别知道了吧?

2、你真的懂吗?

我们知道泛型 List 只能放置一种类型,如果你采用 List 来放置多种类型,然后再进行类型强制转换的话,那会失去了泛型的初衷。

为了能够放置多种类型,于是有了 ,下面先说一些你可能原本就知道的知识:

1、对于 a,a 这个变量可以接受 T 及其 T 子类的集合,上界为 T,并且从 a 取出来的类型都会被强制转换为 T。重点看下面一个例子:

注意:我们先约定 Cat(猫) 继承自 Animal(动物),RedCat(黑猫) 继承自 Cat

    List animals = new ArrayList<>();
    List cats = new ArrayList<>();
    List redCats = new ArrayList<>();
     // 可以通过编译
    List extendsCat = redCats;
     // 不能通过编译,因为只能接受 Cat 及其子类的集合
   extendsCat = animals;
     // 重点注意:下面三行都不能通过编译
    extendsCat.add(new Animal());
    extendsCat.add(new Cat());
    extendsCat.add(new RedCat());
   // 重点注意:可以通过编译
  extendsCat.add(null);

注意,最需要注意的是,就是不能向里面添加除null之外的其他所有元素,这个和 List 有点类似。

2、现在说说 ,它和 有点相反。对于 a,a 这个变量可以接受 T 及其 T 父类的集合,下界为 T,并且从 a 取出来的类型都会被强制转换为 Object。重点看下面一个例子:

   List animals = new ArrayList<>();
   List cats = new ArrayList<>();
   List redCats = new ArrayList<>();
    // 可以通过编译
   List 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 a ,可以把 a 及其 a 的子类赋给 a,从 a 里取的元素都会被强制转换为 T 类型,不过需要注意的是,不能向 a 添加任何除 null 外是元素

2、List 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");
    }

向集合添加元素抛出了如下异常:

image

问题来了,向集合添加元素为啥会抛出异常呢??

我们先来看一下 Arrays.asList(arr) 方法究竟返回了什么?

源码如下:

image

返回的明明是 ArrayList 啊,为啥就不能添加元素呢??

实际上,此 ArrayList 非彼 ArrayList,这个返回的 ArrayList 实际上是 Arrays 的一个内部类。该内部类也是十分简单,和真实的那个 ArrayList 没得比,部分源码如下:

image

而且这个假的 ArrayList 是直接 引用原数组的,不然你看它的构造器(第二条画线)

image

也就是说,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;
    }

你可能感兴趣的:(Java泛型的些许知识)