Java泛型常见面试题

最新推荐文章于 2025-03-24 12:47:13 发布

songzi1228

最新推荐文章于 2025-03-24 12:47:13 发布

阅读量221

点赞数 1

CC 4.0 BY-SA版权

分类专栏： Android：Java 泛型

本文链接：https://blog.youkuaiyun.com/songzi1228/article/details/90475450

Android：Java 同时被 2 个专栏收录

24 篇文章

订阅专栏

泛型

7 篇文章

订阅专栏

本文围绕Java泛型展开，介绍了泛型的定义、好处、工作原理及类型擦除，阐述了限定通配符和非限定通配符的概念，还探讨了泛型方法、泛型类的编写，LRU缓存的实现等内容，同时解答了泛型在数组使用、类型警告处理等方面的常见问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1. Java中的泛型是什么 ? 使用泛型的好处是什么?

2. Java的泛型是如何工作的 ? 什么是类型擦除 ?

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

4. List和List 之间有什么区别 ?

5. 如何编写一个泛型方法，让它能接受泛型参数并返回泛型类型?

6. Java中如何使用泛型编写带有参数的类?

7. 编写一段泛型程序来实现LRU缓存?

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

9. Array中可以用泛型吗?

10. 如何阻止Java中的类型未检查的警告?

11.Java中List和原始类型List之间的区别?

12.Java中List和List之间的区别是什么?

1. Java中的泛型是什么 ? 使用泛型的好处是什么?

JDK1.5以后出现的安全机制

好处：

1、适用于多种数据类型执行相同的代码；
2、使用泛型可以指定数据类型，从而避免强制类型转换，也可以避免传入错误的数据类型。

2. Java的泛型是如何工作的 ? 什么是类型擦除 ?

Java分为编译时期和运行时期。（JAVA之编译期和运行期区别）而泛型是用于编译时期的技术（即给编译器使用），确保了类型的安全，从而提高了编译时期的安全性。

在运行时期，会将泛型去掉，生成的class文件中是不带泛型的，这个称之为泛型的擦除。

为什么要擦除呢？为了兼容运行时的类加载器。因为Java5及之前的类加载器是没有泛型的，识别不了泛型。
但是，一开始的问题又来了！！擦除后，如果你要获取数据的时候又要考虑类型转换的问题（数据的类型被擦除后，都变成了Object类型），那么，这个问题怎么解决呢？如果自己手动强转，那么之前做的就没有意义了。
解决方案就是泛型的补偿机制，这个补偿机制是在类加载器的基础上拓展的，这就意味着之前的类加载器的一套东西不需要改动，在运行时，通过getClass() 获取元素的类型进行自动的类型转换。不用使用者再进行强制转换了。

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

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

4. List<? extends T>和List <? super T>之间有什么区别 ?

这和上一个面试题有联系，有时面试官会用这个问题来评估你对泛型的理解，而不是直接问你什么是限定通配符和非限定通配符。这两个List的声明都是限定通配符的例子，List<? extends T>可以接受任何继承自T的类型的List，而List<? super T>可以接受任何T的父类构成的List。例如List<? extends Number>可以接受List<Integer>或List<Float>。

5. 如何编写一个泛型方法，让它能接受泛型参数并返回泛型类型?

编写泛型方法并不困难，你需要用泛型类型来替代原始类型，比如使用T, E or K,V等被广泛认可的类型占位符。例子如下：

    private T t;

    public T getType() {
        return t;
    }

6. Java中如何使用泛型编写带有参数的类?

这是上一道面试题的延伸。面试官可能会要求你用泛型编写一个类型安全的类，而不是编写一个泛型方法。关键仍然是使用泛型类型来代替原始类型，而且要使用JDK中采用的标准占位符。

public class Tool<T> {

    private T t;

    public T getType() {
        return t;
    }

    public void setType(T t) {
        this.t = t;
    }

}

7. 编写一段泛型程序来实现LRU缓存?

这是一种混合的数据结构，我们需要在哈希表的基础上建立一个链表。但是Java已经为我们提供了这种形式的数据结构-LinkedHashMap！它甚至提供可覆盖回收策略的方法。唯一需要我们注意的事情是，改链表的顺序是插入的顺序，而不是访问的顺序。但是，有一个构造函数提供了一个选项，可以使用访问的顺序。

import java.util.LinkedHashMap;
import java.util.Map;
 
public LRUCache<K, V> extends LinkedHashMap<K, V> {
  private int cacheSize;
 
  public LRUCache(int cacheSize) {
    super(16, 0.75, true);
    this.cacheSize = cacheSize;
  }
 
  protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
    return size() >= cacheSize;
  }
}

具体可见：10行Java代码实现最近被使用（LRU）缓存

8. 你可以把List<String>传递给一个接受List<Object>参数的方法吗？

对任何一个不太熟悉泛型的人来说，这个Java泛型题目看起来令人疑惑，因为乍看起来String是一种Object，所以 List<String>应当可以用在需要List<Object>的地方，但是事实并非如此。真这样做的话会导致编译错误。如果你再深一步考虑，你会发现Java这样做是有意义的，因为List<Object>可以存储任何类型的对象包括String, Integer等等，而List<String>却只能用来存储Strings。

List<Object> objectList;

List<String> stringList;

objectList = stringList; //compilation error incompatible types

9. Array中可以用泛型吗?

这可能是Java泛型面试题中最简单的一个了，当然前提是你要知道Array事实上并不支持泛型，这也是为什么Joshua Bloch在Effective Java一书中建议使用List来代替Array，因为List可以提供编译期的类型安全保证，而Array却不能。

10. 如何阻止Java中的类型未检查的警告?

如果你把泛型和原始类型混合起来使用，例如下列代码，Java 5的javac编译器会产生类型未检查的警告，例如

List<String> rawList = new ArrayList()

注意: Hello.java使用了未检查或称为不安全的操作;

这种警告可以使用@SuppressWarnings(“unchecked”)注解来屏蔽。

        @SuppressWarnings("unchecked")
        List<String> rawList = new ArrayList();

11.Java中List<Object>和原始类型List之间的区别?

原始类型和带参数类型<Object>之间的主要区别是，在编译时编译器不会对原始类型进行类型安全检查，却会对带参数的类型进行检查，通过使用Object作为类型，可以告知编译器该方法可以接受任何类型的对象，比如String或Integer。这道题的考察点在于对泛型中原始类型的正确理解。

它们之间的第二点区别是，你可以把任何带参数的类型传递给原始类型List，但却不能把List<String>传递给接受 List<Object>的方法，因为会产生编译错误。

public class Test2 {
    public static void main(String[] args) {

        List list = new ArrayList();

        List<Object> objectList = new ArrayList<>();
        objectList.add(1);
        objectList.add("哈哈");

        List<String> stringList = new ArrayList<>();
        stringList.add("嘿嘿");

        list.add(stringList);
        objectList.add(stringList);

        System.out.println(objectList.size());
        
        show(objectList);
        show(stringList);

    }

    private static void show(List<Object> objectList) {
        
    }


}

12.Java中List<?>和List<Object>之间的区别是什么?

这道题跟上一道题看起来很像，实质上却完全不同。List<?> 是一个未知类型的List，而List<Object> 其实是任意类型的List。你可以把List<String>, List<Integer>赋值给List<?>，却不能把List<String>赋值给 List<Object>。

List<?> listOfAnyType;

List<Object> listOfObject = new ArrayList<Object>();

List<String> listOfString = new ArrayList<String>();

List<Integer> listOfInteger = new ArrayList<Integer>();

listOfAnyType = listOfString; //legal

listOfAnyType = listOfInteger; //legal

listOfObjectType = (List<Object>) listOfString; //compiler error – in-convertible types

List<String>和原始类型List之间的区别.

该题类似于“原始类型和带参数类型之间有什么区别”。带参数类型是类型安全的，而且其类型安全是由编译器保证的，但原始类型List却不是类型安全的。你不能把String之外的任何其它类型的Object存入String类型的List中，而你可以把任何类型的对象存入原始List中。使用泛型的带参数类型你不需要进行类型转换，但是对于原始类型，你则需要进行显式的类型转换。

List listOfRawTypes = new ArrayList();

listOfRawTypes.add(“abc”);

listOfRawTypes.add(123); //编译器允许这样 – 运行时却会出现异常

String item = (String) listOfRawTypes.get(0); //需要显式的类型转换

item = (String) listOfRawTypes.get(1); //抛ClassCastException，因为Integer不能被转换为String

List<String> listOfString = new ArrayList();

listOfString.add(“abcd”);

listOfString.add(1234); //编译错误，比在运行时抛异常要好

item = listOfString.get(0); //不需要显式的类型转换 – 编译器自动转换

这些都是Java泛型面试中频繁出现的问题及其答案。所有这些面试题都不困难，其实它们都是基于泛型的基础知识。任何对泛型有不错了解的Java程序员都肯定熟知这些泛型题目。