泛型面试问题

淩亂°似流年 2024-02-18 16:17 6阅读 0赞

## 出处：http://blog.csdn.net/sunxianghuang/article/details/51982979 ##

## 泛型相关面试题 ##

1. Java中的泛型是什么 ? 使用泛型的好处是什么?  
泛型是一种参数化类型的机制。它可以使得代码适用于各种类型，从而编写更加通用的代码，例如集合框架。

泛型是一种编译时类型确认机制。它提供了编译期的类型安全，确保在泛型类型（通常为泛型集合）上只能使用正确类型的对象，避免了在运行时出现ClassCastException。

2、Java的泛型是如何工作的 ? 什么是类型擦除 ?  
泛型的正常工作是依赖编译器在编译源码的时候，先进行类型检查，然后进行类型擦除并且在类型参数出现的地方插入强制转换的相关指令实现的。

编译器在编译时擦除了所有类型相关的信息，所以在运行时不存在任何类型相关的信息。例如List<String>在运行时仅用一个List类型来表示。为什么要进行擦除呢？这是为了避免类型膨胀。

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等被广泛认可的类型占位符。泛型方法的例子请参阅Java集合类框架。最简单的情况下，一个泛型方法可能会像这样:

\[java\] [view plain][] [copy][view plain]

1.  **public** V put(K key, V value) \{ 
2.  **return** cache.put(key, value); 
3.  \}

6. Java中如何使用泛型编写带有参数的类?  
这是上一道面试题的延伸。面试官可能会要求你用泛型编写一个类型安全的类，而不是编写一个泛型方法。关键仍然是使用泛型类型来代替原始类型，而且要使用JDK中采用的标准占位符。  
7. 编写一段泛型程序来实现LRU缓存?  
对于喜欢Java编程的人来说这相当于是一次练习。给你个提示，LinkedHashMap可以用来实现固定大小的LRU缓存，当LRU缓存已经满了的时候，它会把最老的键值对移出缓存。LinkedHashMap提供了一个称为removeEldestEntry()的方法，该方法会被put()和putAll()调用来删除最老的键值对。  
8. 你可以把List<String>传递给一个接受List<Object>参数的方法吗？  
对任何一个不太熟悉泛型的人来说，这个Java泛型题目看起来令人疑惑，因为乍看起来String是一种Object，所以List<String>应当可以用在需要List<Object>的地方，但是事实并非如此。真这样做的话会导致编译错误。如果你再深一步考虑，你会发现Java这样做是有意义的，因为List<Object>可以存储任何类型的对象包括String, Integer等等，而List<String>却只能用来存储Strings。

\[java\] [view plain][] [copy][view plain]

1.  List<Object> objectList; 
2.  List<String> stringList; 
3.  
4.  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")注解来屏蔽。

11、Java中List<Object>和原始类型List之间的区别?  
原始类型和带参数类型<Object>之间的主要区别是，在编译时编译器不会对原始类型进行类型安全检查，却会对带参数的类型进行检查，通过使用Object作为类型，可以告知编译器该方法可以接受任何类型的对象，比如String或Integer。这道题的考察点在于对泛型中原始类型的正确理解。它们之间的第二点区别是，你可以把任何带参数的泛型类型传递给接受原始类型List的方法，但却不能把List<String>传递给接受List<Object>的方法，因为会产生编译错误。

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

\[java\] [view plain][] [copy][view plain]

1.  List<?> listOfAnyType; 
2.  List<Object> listOfObject = **new** ArrayList<Object>(); 
3.  List<String> listOfString = **new** ArrayList<String>(); 
4.  List<Integer> listOfInteger = **new** ArrayList<Integer>(); 
5.  
6.  listOfAnyType = listOfString; //legal
7.  listOfAnyType = listOfInteger; //legal
8.  listOfObjectType = (List<Object>) listOfString; //compiler error - in-convertible types

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

\[java\] [view plain][] [copy][view plain]

1.  List listOfRawTypes = **new** ArrayList(); 
2.  listOfRawTypes.add("abc"); 
3.  listOfRawTypes.add(123); //编译器允许这样 - 运行时却会出现异常
4.  String item = (String) listOfRawTypes.get(0); //需要显式的类型转换
5.  item = (String) listOfRawTypes.get(1); //抛ClassCastException，因为Integer不能被转换为String
6.  
7.  List<String> listOfString = **new** ArrayList(); 
8.  listOfString.add("abcd"); 
9.  listOfString.add(1234); //编译错误，比在运行时抛异常要好
10. item = listOfString.get(0); //不需要显式的类型转换 - 编译器自动转换

## 通配符 ##

### 通配符上界 ###

常规使用

\[java\] [view plain][] [copy][view plain]

1.  **public****class** Test \{ 
2.  **public****static****void** printIntValue(List<? **extends** Number> list) \{ 
3.  **for** (Number number : list) \{ 
4.   System.out.print(number.intValue()+" "); 
5.   \} 
6.   System.out.println(); 
7.   \} 
8.  **public****static****void** main(String\[\] args) \{ 
9.   List<Integer> integerList=**new** ArrayList<Integer>(); 
10.  integerList.add(2); 
11.  integerList.add(2); 
12.  printIntValue(integerList); 
13.  List<Float> floatList=**new** ArrayList<Float>(); 
14.  floatList.add((**float**) 3.3); 
15.  floatList.add((**float**) 0.3); 
16.  printIntValue(floatList); 
17.  \} 
18. \}

输出：

2 2  
3 0

非法使用

\[java\] [view plain][] [copy][view plain]

1.  **public****class** Test \{ 
2.  **public****static****void** fillNumberList(List<? **extends** Number> list) \{ 
3.   list.add(**new** Integer(0));//编译错误
4.   list.add(**new** Float(1.0));//编译错误
5.   \} 
6.  **public****static****void** main(String\[\] args) \{ 
7.   List<? **extends** Number> list=**new** ArrayList(); 
8.   list.add(**new** Integer(1));//编译错误
9.   list.add(**new** Float(1.0));//编译错误
10.  \} 
11. \}

List<? extends Number>可以代表List<Integer>或List<Float>，为什么不能像其中加入Integer或者Float呢？

首先，我们知道List<Integer>之中只能加入Integer。并且如下代码是可行的：

\[java\] [view plain][] [copy][view plain]

1.  List<? **extends** Number> list1=**new** ArrayList<Integer>(); 
2.  List<? **extends** Number> list2=**new** ArrayList<Float>();

假设前面的例子没有编译错误，如果我们把list1或者list2传入方法fillNumberList，显然都会出现类型不匹配的情况， 假设不成立。

因此，我们得出结论：不能往List<? extends T> 中添加任意对象，除了null。

那为什么对List<? extends T>进行迭代可以呢，因为子类必定有父类相同的接口，这正是我们所期望的。

### 通配符下界 ###

常规使用

\[java\] [view plain][] [copy][view plain]

1.  **public****class** Test \{ 
2.  **public****static****void** fillNumberList(List<? **super** Number> list) \{ 
3.   list.add(**new** Integer(0)); 
4.   list.add(**new** Float(1.0)); 
5.   \} 
6.  **public****static****void** main(String\[\] args) \{ 
7.   List<? **super** Number> list=**new** ArrayList(); 
8.   list.add(**new** Integer(1)); 
9.   list.add(**new** Float(1.1)); 
10.  \} 
11. \}

可以添加Number的任何子类，为什么呢？

List<? super Number>可以代表List<T>，其中T为Number父类，（虽然Number没有父类）。如果说，T为Number的父类，我们想List<T>中加入Number的子类肯定是可以的。

非法使用

对List<? superT>进行迭代是不允许的。为什么呢？你知道用哪种接口去迭代List吗？只有用Object类的接口才能保证集合中的元素都拥有该接口，显然这个意义不大。其应用场景略。

### 无界通配符 ###

知道了通配符的上界和下界，其实也等同于知道了无界通配符，不加任何修饰即可，单独一个“？”。如List<?>，“？”可以代表任意类型，“任意”也就是未知类型。

List<Object>与List<?>并不等同，List<Object>是List<?>的子类。还有不能往List<?> list里添加任意对象，除了null。  
常规使用

1、当方法是使用原始的Object类型作为参数时，如下：

\[java\] [view plain][] [copy][view plain]

1.  **public****static****void** printList(List<Object> list) \{ 
2.  **for** (Object elem : list) 
3.   System.out.println(elem + ""); 
4.   System.out.println(); 
5.  \}

可以选择改为如下实现：

\[java\] [view plain][] [copy][view plain]

1.  **public****static****void** printList(List<?> list) \{ 
2.  **for** (Object elem: list) 
3.   System.out.print(elem + ""); 
4.   System.out.println(); 
5.  \}

这样就可以兼容更多的输出，而不单纯是List<Object>,如下：

\[java\] [view plain][] [copy][view plain]

1.  List<Integer> li = Arrays.asList(1, 2, 3); 
2.  List<String> ls = Arrays.asList("one", "two", "three"); 
3.  printList(li); 
4.  printList(ls);

## 泛型相关问题 ##

1、泛型类型引用传递问题

在Java中，像下面形式的引用传递是不允许的：

\[java\] [view plain][] [copy][view plain]

1.  ArrayList<String> arrayList1=**new** ArrayList<Object>();//编译错误 
2.  ArrayList<Object> arrayList1=**new** ArrayList<String>();//编译错误

我们先看第一种情况，将第一种情况拓展成下面的形式：

\[java\] [view plain][] [copy][view plain]

1.  ArrayList<Object> arrayList1=**new** ArrayList<Object>(); 
2.   arrayList1.add(**new** Object()); 
3.   arrayList1.add(**new** Object()); 
4.   ArrayList<String> arrayList2=arrayList1;//编译错误

实际上，在第4行代码处，就会有编译错误。那么，我们先假设它编译没错。那么当我们使用arrayList2引用用get()方法取值的时候，返回的都是String类型的对象，可是它里面实际上已经被我们存放了Object类型的对象，这样，就会有ClassCastException了。所以为了避免这种极易出现的错误，Java不允许进行这样的引用传递。（这也是泛型出现的原因，就是为了解决类型转换的问题，我们不能违背它的初衷）。  
在看第二种情况，将第二种情况拓展成下面的形式：

\[java\] [view plain][] [copy][view plain]

1.  ArrayList<String> arrayList1=**new** ArrayList<String>(); 
2.   arrayList1.add(**new** String()); 
3.   arrayList1.add(**new** String()); 
4.   ArrayList<Object> arrayList2=arrayList1;//编译错误

没错，这样的情况比第一种情况好的多，最起码，在我们用arrayList2取值的时候不会出现ClassCastException，因为是从String转换为Object。可是，这样做有什么意义呢，泛型出现的原因，就是为了解决类型转换的问题。我们使用了泛型，到头来，还是要自己强转，违背了泛型设计的初衷。所以java不允许这么干。再说，你如果又用arrayList2往里面add()新的对象，那么到时候取得时候，我怎么知道我取出来的到底是String类型的，还是Object类型的呢？  
所以，要格外注意泛型中引用传递问题。

2、泛型类型变量不能是基本数据类型  
就比如，没有ArrayList<double>，只有ArrayList<Double>。因为当类型擦除后，ArrayList的原始类中的类型变量（T）替换为Object，但Object类型不能存储double值。  
3、运行时类型查询  
举个例子:

\[java\] [view plain][] [copy][view plain]

1.  ArrayList<String> arrayList=**new** ArrayList<String>();

因为类型擦除之后，ArrayList<String>只剩下原始类型，泛型信息String不存在了。那么，运行时进行类型查询的时候使用下面的方法是错误的

\[java\] [view plain][] [copy][view plain]

1.  **if**( arrayList **instanceof** ArrayList<String>)

java限定了这种类型查询的方式，？为通配符，也即非限定符。

\[java\] [view plain][] [copy][view plain]

1.  **if**( arrayList **instanceof** ArrayList<?>)

4、泛型在静态方法和静态类中的问题

泛型类中的静态方法和静态变量不可以使用泛型类所声明的泛型类型参数

\[java\] [view plain][] [copy][view plain]

1.  **public****class** Test2<T> \{ 
2.  **public****static** T one; //编译错误 
3.  **public****static** T show(T one)\{ //编译错误 
4.  **return****null**; 
5.   \} 
6.  \}

因为泛型类中的泛型参数的实例化是在定义泛型类型对象（例如ArrayList<Integer>）的时候指定的，而静态变量和静态方法不需要使用对象来调用。对象都没有创建，如何确定这个泛型参数是何种类型，所以当然是错误的。

但是要注意区分下面的一种情况：

\[java\] [view plain][] [copy][view plain]

1.  **public****class** Test2<T> \{ 
2.  **public****static** <T >T show(T one)\{ //这是正确的 
3.  **return****null**; 
4.   \} 
5.  \}

因为这是一个泛型方法，在泛型方法中使用的T是自己在方法中定义的T，而不是泛型类中的T。

[view plain]: http://blog.csdn.net/sunxianghuang/article/details/51982979#