Java泛型面试总结

Java中的泛型是什么 ? 有什么作用？

Java 泛型（Generics） 是 JDK 1.5 中引入的一个新特性。泛型就是将类型参数化，其在编译时才确定具体的参数。 这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

使用泛型参数，可以增强代码的可读性以及稳定性。

编译器可以对泛型参数进行检测，并且通过泛型参数可以指定传入的对象类型。比如 ArrayList persons = new ArrayList() 这行代码就指明了该 ArrayList 对象只能传入 Person 对象，如果传入其他类型的对象就会报错。

ArrayList<E> extends AbstractList<E>

并且，原生 List 返回类型是 Object ，需要手动转换类型才能使用，使用泛型后编译器自动转换。

使用泛型的好处是什么?

远在 JDK 1.4 版本的时候，那时候是没有泛型的概念的，如果使用 Object 来实现通用、不同类型的处理，有这么两个缺点：

1. 每次使用时都需要强制转换成想要的类型
2. 在编译时编译器并不知道类型转换是否正常，运行时才知道，不安全。

如这个例子：

List list = new ArrayList();
list.add("www.cnblogs.com");
list.add(23);
String name = (String)list.get(0);
String number = (String)list.get(1);	//ClassCastException

上面的代码在运行时会发生强制类型转换异常。这是因为我们在存入的时候，第二个是一个 Integer 类型，但是取出来的时候却将其强制转换为 String 类型了。Sun 公司为了使 Java 语言更加安全，减少运行时异常的发生。于是在 JDK 1.5 之后推出了泛型的概念。

根据《Java 编程思想》中的描述，泛型出现的动机在于：有许多原因促成了泛型的出现，而最引人注意的一个原因，就是为了创建容器类。

使用泛型的好处有以下几点：

类型安全

1. 泛型的主要目标是提高 Java 程序的类型安全
2. 编译时期就可以检查出因 Java 类型不正确导致的 ClassCastException 异常
3. 符合越早出错代价越小原则

消除强制类型转换

1. 泛型的一个附带好处是，使用时直接得到目标类型，消除许多强制类型转换
2. 所得即所需，这使得代码更加可读，并且减少了出错机会

潜在的性能收益

1. 由于泛型的实现方式，支持泛型（几乎）不需要 JVM 或类文件更改
2. 所有工作都在编译器中完成
3. 编译器生成的代码跟不使用泛型（和强制类型转换）时所写的代码几乎一致，只是更能确保类型安全而已

泛型的使用方式有哪几种？

泛型一般有三种使用方式:泛型类、泛型接口、泛型方法。

1.泛型类：

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic<T>{

    private T key;

    public Generic(T key) {
        this.key = key;
    }

    public T getKey(){
        return key;
    }
}

如何实例化泛型类：

Generic<Integer> genericInteger = new Generic<Integer>(123456);

2.泛型接口 ：

public interface Generator<T> {
    public T method();
}

实现泛型接口，不指定类型：

class GeneratorImpl<T> implements Generator<T>{
    @Override
    public T method() {
        return null;
    }
}

实现泛型接口，指定类型：

class GeneratorImpl<T> implements Generator<String>{
    @Override
    public String method() {
        return "hello";
    }
}

3.泛型方法 ：

   public static < E > void printArray( E[] inputArray )
   {
         for ( E element : inputArray ){
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }

使用：

// 创建不同类型数组： Integer, Double 和 Character
Integer[] intArray = { 1, 2, 3 };
String[] stringArray = { "Hello", "World" };
printArray( intArray  );
printArray( stringArray  );

注意: public static < E > void printArray( E[] inputArray ) 一般被称为静态泛型方法；在 java 中泛型只是一个占位符，必须在传递类型后才能使用。类在实例化时才能真正的传递类型参数，由于静态方法的加载先于类的实例化，也就是说类中的泛型还没有传递真正的类型参数，静态的方法的加载就已经完成了，所以静态泛型方法是没有办法使用类上声明的泛型的。只能使用自己声明的 。

Java泛型的原理是什么 ? 什么是类型擦除 ?

泛型是一种语法糖，泛型这种语法糖的基本原理是类型擦除。Java中的泛型基本上都是在编译器这个层次来实现的，也就是说：**泛型只存在于编译阶段，而不存在于运行阶段。**在编译后的 class 文件中，是没有泛型这个概念的。

类型擦除：使用泛型的时候加上的类型参数，编译器在编译的时候去掉类型参数。

例如：

public class Caculate<T> {
    private T num;
}

我们定义了一个泛型类，定义了一个属性成员，该成员的类型是一个泛型类型，这个 T 具体是什么类型，我们也不知道，它只是用于限定类型的。反编译一下这个 Caculate 类：

public class Caculate{
    public Caculate(){}
    private Object num;
}

发现编译器擦除 Caculate 类后面的两个尖括号，并且将 num 的类型定义为 Object 类型。

那么是不是所有的泛型类型都以 Object 进行擦除呢？大部分情况下，泛型类型都会以 Object 进行替换，而有一种情况则不是。那就是使用到了 extends 和 super 语法的有界类型，如：

public class Caculate<T extends String> {
    private T num;
}

这种情况的泛型类型，num 会被替换为 String 而不再是 Object。这是一个类型限定的语法，它限定 T 是 String 或者 String 的子类，也就是你构建 Caculate 实例的时候只能限定 T 为 String 或者 String 的子类，所以无论你限定 T 为什么类型，String 都是父类，不会出现类型不匹配的问题，于是可以使用 String 进行类型擦除。

实际上编译器会正常的将使用泛型的地方编译并进行类型擦除，然后返回实例。但是除此之外的是，如果构建泛型实例时使用了泛型语法，那么编译器将标记该实例并关注该实例后续所有方法的调用，每次调用前都进行安全检查，非指定类型的方法都不能调用成功。

实际上编译器不仅关注一个泛型方法的调用，它还会为某些返回值为限定的泛型类型的方法进行强制类型转换，由于类型擦除，返回值为泛型类型的方法都会擦除成 Object 类型，当这些方法被调用后，编译器会额外插入一行 checkcast 指令用于强制类型转换。这一个过程就叫做『泛型翻译』。

我在这里想要详细解释一下类型擦除这个概念，上面的大多数都是废话，网上也能搜到，之所以还要再次罗列不过是因为更多的例子能让大家更好理解，有时候多看一些比较松散的例子也能有意想不到的收获。

所谓类型擦除，就是指我们在编写代码时设置泛型，类似这样 List<String> list = new ArrayList<>();，这样做了之后有什么好处呢？在之后我们通过list.add()添加数据时，编译器会帮我们自动检测，如果类型不符合就会报错。OK，添加完数据，做完相应工作后，进行编译，Java程序变为字节码，这个时候，所有的泛型信息都会被擦除，就像上面的例子 变为 Object。既然我在编译之后泛型被擦除了，那我调用list.get()方法时如何保证我得到结果是泛型类型呢？答案是在调用get()方法的地方会为我们做一个强转，需要注意的是这里指的是调用get()方法的地方而不是get()方法内。

为什么要进行类型擦除

Java泛型的类型擦除是为了保证通用性和兼容性，同时避免了类型检查和运行时类型转换所带来的大量性能损失和代码复杂度。

在Java泛型中，编译器在编译时将泛型类型转换成具体类型。这样一来，Java运行时系统就不需要知道之前的程序中所使用过的泛型类型，这也就是所说的类型擦除。具体来说，Java实现泛型的方法是通过类型变量来达到泛型的效果，在编译期通过检查类型变量是否符合指定的限制来保证程序的类型安全性。通过在编译期进行类型检查，可以确保程序的类型安全，从而避免了在运行期间进行类型转换的性能损失和代码复杂度。

另外，类型擦除还可以使得Java泛型的代码更简单易懂，从而提高代码的可读性和可维护性。Java泛型类型擦除的实现并未提高Java泛型的表达能力，而是以减少运行时类型转换和提高代码可读性为代价来提高Java泛型的兼容性和通用性。

最后，类型擦除是Java泛型实现的必要过程，也是Java泛型可以与现有代码库兼容的原因之一。因此，类型擦除是Java泛型得以被广泛使用的重要特征。

什么是泛型中的限定通配符和非限定通配符 ?

限定通配符对类型进行了限制。有两种限定通配符，一种是 <? extends T> 它通过确保类型必须是 T 的子类来设定类型的上界，另一种是 <? super T> 它通过确保类型必须是 T 的父类来设定类型的下界。泛型类型必须用限定内的类型来进行初始化，否则会导致编译错误。

非限定通配符 ？,可以用任意类型来替代。如List<?> 的意思是这个集合是一个可以持有任意类型的集合，它可以是List，也可以是List，或者List等等。

可以把List传递给一个接受List参数的方法吗？

不可以。真这样做的话会导致编译错误。因为List可以存储任何类型的对象包括String, Integer等等，而List却只能用来存储String。

List<Object> objectList;
List<String> stringList;
objectList = stringList;  //compilation error incompatible types

Array中可以用泛型吗?

不可以。这也是为什么 Joshua Bloch 在 《Effective Java》一书中建议使用 List 来代替 Array，因为 List 可以提供编译期的类型安全保证，而 Array 却不能。

判断ArrayList与ArrayList是否相等？

ArrayList<String> a = new ArrayList<String>();
ArrayList<Integer> b = new ArrayList<Integer>();
Class c1 = a.getClass();
Class c2 = b.getClass();
System.out.println(c1 == c2); 

输出的结果是 true。因为无论对于 ArrayList 还是 ArrayList，它们的 Class 类型都是一直的，都是 ArrayList.class。

那它们声明时指定的 String 和 Integer 到底体现在哪里呢？

**答案是体现在类编译的时候。**当 JVM 进行类编译时，会进行泛型检查，如果一个集合被声明为 String 类型，那么它往该集合存取数据的时候就会对数据进行判断，从而避免存入或取出错误的数据。

项目中哪里用到了泛型？

• 自定义接口通用返回结果 CommonResult 通过参数 T 可根据具体的返回类型动态指定结果的数据类型

• 定义 Excel 处理类 ExcelUtil 用于动态指定 Excel 导出的数据类型

• 构建集合工具类（参考 Collections 中的 sort, binarySearch 方法）。

• …