来源:

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 和几个子类，如狗、猫等，现在我需要一个动物的列表，我的第一个想法是像这样的：

List<Animal>listAnimals

但是老板的想法确实这样的：

 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<Dog> dogs =  new  ArrayList<>();
// 不会报错
countLegs( dogs );
// 报错
countLegs1(dogs);
}

当调用 countLegs1 时，就会飘红，提示的错误信息如下：

所以，对于不确定或者不关心实际要操作的类型，可以使用无限制通配符（尖括号里一个问号，即），表示可以持有任何类型。像 countLegs 方法中，限定了上届，但是不关心具体类型是什么，所以对于传入的 Animal 的所有子类都可以支持，并且不会报错。而 countLegs1 就不行。

上界通配符

上届：用 extends 关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类。

在类型参数中使用 extends 表示这个泛型中的参数必须是 E 或者 E 的子类，这样有两个好处：

如果传入的类型不是 E 或者 E 的子类，编译不成功
泛型中可以使用 E 的方法，要不然还得强转成 E 才能使用

private  <K extends A, E extends B> E test(K arg1, E arg2){
E result = arg2;
arg2.compareTo(arg1);
//.....
return result;
}

类型参数列表中如果有多个类型参数上限，用逗号分开

下界通配符

下界: 用 super 进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至 Object

在类型参数中使用 super 表示这个泛型中的参数必须是 E 或者 E 的父类。

private  <T>  void test(List<?  super T> dst,  List<T> src){
for  (T t : src)  {
dst.add(t);
}
}
public  static  void main(String[] args)  {
List<Dog> dogs =  new  ArrayList<>();
List<Animal> 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  <T extends  Number>  void
 test(List<T> dest,  List<T> src)
//通配符是 不确定的，所以这个方法不能保证两个 List 具有相同的元素类型
public  void
test(List<?  extends  Number> dest,  List<?  extends  Number> src)

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

image

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

GlmapperGeneric<String> glmapperGeneric =  new  GlmapperGeneric<>();
List<String> dest =  new  ArrayList<>();
List<Number> 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<T> 和 Class<?>`区别

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

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

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

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

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

image

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

// 可以
public  Class<?> clazz;
// 不可以，因为 T 需要指定类型
public  Class<T> clazzT;

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

image

那如果也想 publicClass<T>clazzT; 这样的话，就必须让当前的类也指定 T ，

public  class  Test3<T>  {`
public  Class<?> clazz;`
// 不会报错`
public  Class<T> clazzT;`

背后的原理

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

类型擦除带来的局限性

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

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

image

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

public interface List<E> extends Collection<E>{    boolean add(E e);}

上面是 List 和其中的 add() 方法的源码定义。

因为 E 代表任意的类型，所以类型擦除时，add 方法其实等同于

boolean add(Object obj);

那么，利用反射，我们绕过编译器去调用 add 方法。

public class ToolTest {
   public static void main(String[] args) {
       List<Integer> 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<int> li = new ArrayList<>();List<boolean> li = new ArrayList<>();

需要使用它们对应的包装类。

List<Integer> li = new ArrayList<>();List<Boolean> li1 = new ArrayList<>();

对泛型方法的困惑

public <T> T test(T t){   return null;}

有的同学可能对于连续的两个 T 感到困惑，其实 <T> 是为了说明类型参数，是声明,而后面的不带尖括号的 T 是方法的返回值类型。
你可以相像一下，如果 test() 这样被调用

test("123");

那么实际上相当于

public String test(String t);

Java 不能创建具体类型的泛型数组

这句话可能难以理解，代码说明。

List<Integer>[] li2 = new ArrayList<Integer>[];List<Boolean> li3 = new ArrayList<Boolean>[];

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

List<Integer> 和 List<Boolean> 在 jvm 中等同于List<Object> ，所有的类型信息都被擦除，程序也无法分辨一个数组中的元素类型具体是 List<Integer>类型还是 List<Boolean> 类型。

但是，

List<?>[] li3 = new ArrayList<?>[10];li3[1] = new ArrayList<String>();List<?> v = li3[1];

借助于无限定通配符却可以，前面讲过 ？ 代表未知类型，所以它涉及的操作都基本上与类型无关，因此 jvm 不需要针对它对类型作判断，因此它能编译通过，但是，只提供了数组中的元素因为通配符原因，它只能读，不能写。比如，上面的 v 这个局部变量，它只能进行 get() 操作，不能进行 add() 操作，这个在前面通配符的内容小节中已经讲过。

泛型中的陷阱

1、List ，List<?> 与 List<Object> 有区别吗？

说实话，我敢保证很多人是不知道 List, List<?> 与 List<Object> 之间的区别的。

1、我们先来看看 List 与 List<Object>

很多可能觉得 List<Object>的用法与 List 是一样的，例如很多人认为
List<Object> list;与List list;

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

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

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

image

从这里可以看出

List list;与List<Object> list;

是有区别的，List <?>变量可以接受任何泛型的变量，而 List<Object>则不可以。

2、我们在看看 Lis<?> 有什么需要注意的地方：

看下面一段代码：

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

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

image

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

List 与 List<?>, List<Object> 的细微区别知道了吧？

2、<? extends T> 与 <? super T>你真的懂吗？

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

为了能够放置多种类型，于是有了 <? extend T> 与 <? super T>，下面先说一些你可能原本就知道的知识：

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

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

    List<Animal> animals = new ArrayList<>();
    List<Cat> cats = new ArrayList<>();
    List<RedCat> 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<Animal> animals = new ArrayList<>();
   List<Cat> cats = new ArrayList<>();
   List<RedCat> 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<Integer> list) {
        System.out.println("List<Integer> list");
    }
    public static void method(List<String> list) {
        System.out.println("List<String> list");
    }
}

答是编译不通过。

两个方法的参数不同，为什么会重载不通过呢？

实际上在 Java 的泛型中，泛型只存在于源码中，在编译后的字节码中，泛型已经被替换为原生类型了，并且在相应的地方插入了强制转换的代码。为了方便理解，可以看下面的一段代码例子：

// 源码
     public static void main(String[] args) {
       List<Integer> 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<String> 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<String> list = Arrays.asList(arr);
       // 修改 arr
        arr[0] = "0";
        //打印看看
        System.out.println(list.get(0));
    }

打印结果是 “0”。

所以，我们向 list 添加元素肯定失败，因为 arr 数组的长度了 3 ，本来就有 3 个元素了，你在向里面添加第四个元素，肯定是不行的。

所以，在把数组转换为集合的过程中，需要特别注意。

建议大家这样转换比较安全

List<String> list = new ArrayList<>(Arrays.asList(arr));

2、集合转数组

集合转换为数组相对比较不苛刻，我就不拉很多源码来进行分析了，我只简单说下几个需要注意的地方。例如对于下面这个转换：

    // 集合大小为 size
    List<String> list = new ArrayList<>();
    // 长度为 n 的数组
    String[] arr = new String[n];
    // 进行转换
    list.toArray(arr);

1、如果数组长度比集合小：由于 arr 的长度不够，所以集合里的元素不会赋给 arr，而且自己再重新创建一个新数组反回去。

2、如果数组长度不小于集合：此时 arr 的长度够了，所以集合里的元素直接复制给 arr 数组，不会重新创建一个新的元素。

一览源码：

 public <T> 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泛型的些许知识

Java泛型的些许知识

来源:

好处：

泛型中通配符

常用的 T，E，K，V，？

？无界通配符

上界通配符

下界通配符

？和 T 的区别

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

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

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

Class<T> 和 Class<?>`区别

背后的原理

类型擦除带来的局限性

泛型中值得注意的地方

泛型类或者泛型方法中，不接受 8 种基本数据类型。

对泛型方法的困惑

Java 不能创建具体类型的泛型数组

泛型中的陷阱

1、List ，List<?> 与 List<Object> 有区别吗？

2、<? extends T> 与 <? super T>你真的懂吗？

3、泛型与重载

4、数组与集合相互转换时需要注意的点

Java泛型的些许知识

来源:

好处：

泛型中通配符

常用的 T，E，K，V，？

？ 无界通配符

上界通配符

下界通配符

？和 T 的区别

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

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

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

Class<T> 和 Class<?>`区别

背后的原理

类型擦除带来的局限性

泛型中值得注意的地方

泛型类或者泛型方法中，不接受 8 种基本数据类型。

对泛型方法的困惑

Java 不能创建具体类型的泛型数组

泛型中的陷阱

1、List ，List<?> 与 List<Object> 有区别吗？

2、<? extends T> 与 <? super T>你真的懂吗？

3、泛型与重载

4、数组与集合相互转换时需要注意的点

？无界通配符

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