Java基础常见面试题（六）

路上阡陌

已于 2024-02-14 09:54:28 修改

阅读量282

点赞数 5

分类专栏： # JavaSE 文章标签： java 面试开发语言

于 2023-02-27 08:31:51 首次发布

本文链接：https://blog.csdn.net/m0_51431003/article/details/128933676

版权

JavaSE 专栏收录该内容

9 篇文章 4 订阅

订阅专栏

泛型

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

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

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

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

ArrayList<E> extends AbstractList<E>

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

使用泛型的好处是什么?

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

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

如这个例子：

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 编程思想》中的描述，泛型出现的动机在于：有许多原因促成了泛型的出现，而最引人注意的一个原因，就是为了创建容器类。

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

类型安全

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

消除强制类型转换

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

潜在的性能收益

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

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

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

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()方法内。

通过使用泛型，我们可以让编译器在编译期间检查变量的数据类型是否正确，从而减少运行期错误的概率，增加程序的健壮性。而在运行期间，由于泛型类型信息被擦除了，所以我们无法直接得到元素的实际类型参数。不过，编译期间所生成的字节码文件中会保存一部分泛型类型信息，这些信息可以在运行期间反射获取到。

当你调用 list.get() 方法时，如果在这段代码的上下文中已经确定了元素的类型，那么编译器会自动进行类型转换，保证返回值的类型与指定的泛型类型相同。例如：

List<String> list = new ArrayList<>();
list.add("hello");
String str = list.get(0); // 这里编译器会自动将 Object 类型转换为 String 类型

如果在上下文中无法确定元素的类型，那么返回值类型将会是 Object。例如：

List list = new ArrayList();
list.add("hello");
Object obj = list.get(0); // 返回值类型为 Object 类型

需要注意的是，使用时如果强制转换得到的结果类型错误，可能会导致运行时异常，比如 ClassCastException。因此在转换类型时需要进行类型检查，避免出现类型错误的情况。

如果想要详细理解泛型相关的知识，可以参考这篇文章——ava泛型（二）、泛型的内部原理：类型擦除以及类型擦除带来的问题

强烈推荐大家看这篇文章，绝对精品！！！

为什么要进行类型擦除

Java中的泛型是基于类型擦除实现的，这意味着在编译期间，Java编译器会将泛型类型擦除为其边界类型或Object类型。这是为了保证Java程序在运行时的向后兼容性和互操作性。

具体来说，类型擦除的主要作用有以下几点：

泛型类型擦除可以避免出现类型转换异常。在Java中，泛型类型是在编译期间进行类型检查的，而在运行时，泛型类型会被擦除为其边界类型或Object类型。这样可以保证Java程序不会出现类型转换异常等问题。
泛型类型擦除可以提高Java程序的性能。泛型类型擦除可以避免在运行时进行类型检查和类型转换，从而提高程序的性能。
泛型类型擦除可以提高Java程序的向后兼容性。在Java 1.4版本之前，Java没有泛型类型，所有的集合类型都是Object类型。在引入泛型之后，为了保证Java程序的向后兼容性，Java使用了类型擦除的方式来实现泛型类型。
泛型类型擦除可以提高Java程序的互操作性。Java程序可以与其他语言编写的程序进行互操作，而其他语言可能不支持泛型类型。通过使用类型擦除的方式来实现泛型类型，Java程序可以与其他语言编写的程序进行互操作。

综上所述，类型擦除是Java泛型的重要特性之一，它可以保证Java程序的类型安全性、性能、向后兼容性和互操作性。

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

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

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

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

不可以。真这样做的话会导致编译错误。因为objectList可以存储任何类型的对象包括String, Integer等等，而stringList却只能用来存储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);