Java 泛型

Java 泛型是 Java 5 引入的一个重要特性,相信大多数 Java 开发者都对此不陌生,但是泛型背后的实现原理和类型擦除还是许多人依然不是很清楚。本文将介绍 Java 泛型的原理和使用,重点阐述容易产生困惑的通配符、类型擦除等问题。

1. Java 泛型

1.1 Java 泛型是什么?

Java 泛型,提供了参数化类型,并且提供了编译时强类型检查。泛型可以让我们很简单地支持不同类型,在 Java 集合框架中泛型广泛用以对类型的抽象。

1.2 Java 泛型的好处

  • 提供编译时的强类型检查。可以在编译时发现类型安全问题,不用等到运行时。

  • 避免类型转换。

看下面一段代码:

1
2
3
List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0); // type cast to String

如果使用泛型的话,不需要类型转换:

1
2
3
List<String> list = new ArrayList<String>();
list.add("hello");
String s = list.get(0); // no cast
  • 可以实现通用的算法。通用算法可以处理不同类型的集合,可以进行自定义,并且类型安全且易于阅读。

2. 泛型类型与泛型方法

2.1 泛型类型

泛型类型是指泛型类或泛型接口。为了理解泛型类型的概念,看下面这个例子。

先定义一个简单的 Box 类:

1
2
3
4
5
6
public class Box {
private String object;
public void set(String object) { this.object = object; }
public String get() { return object; }
}

上面代码中的 Box 只能存放 String 类型的元素,如果想存放 Integer 等其他类型的元素,则必须重写另外一个 Box,代码不能复用。下面再看使用泛型后的 Box:

1
2
3
4
5
6
7
public class Box<T> {
// T stands for "Type"
private T t;
public void set(T t) { this.t = t; }
public T get() { return t; }
}

现在 Box 可以存放除基本类型外的任何类型了。使用 T 类型代替 String 类型,按照惯例,类型参数名是一个大写字母,常见的类型参数名如下:

  • E - Element(在 Java 集合框架中广泛运用)

  • K - Key

  • N - Number

  • T - Type

  • V - Value

2.2 泛型类型的原始类型(Raw Types)

原始类型(Raw Types)是没有指定参数类型的泛型类或泛型接口。例如,对于上面提到的Box<T>泛型类:

1
Box rawBox = new Box();

Box就是Box<T>的原始类型,原始类型一般出现在旧版代码中,因为大量的 API 在 Java 5 之前不是通用的。原始类型和泛型类型也可以转换:

1
2
3
4
5
6
7
8
// generic type to raw type
Box<String> stringBox = new Box<>();
Box rawBox = stringBox; // OK
rawBox.set(8); // warning: unchecked invocation to set(T)
// raw type to generic type
Box rawBox = new Box(); // rawBox is a raw type of Box<T>
Box<Integer> intBox = rawBox; // warning: unchecked conversion

2.3 泛型方法

泛型方法是指有它们自己参数化类型的方法。类型参数在一对尖括号之间,并且在方法返回类型之前。

下面 Util 类有一个泛型方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Util {
public static <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) {
return p1.getKey().equals(p2.getKey()) &&
p1.getValue().equals(p2.getValue());
}
}
public class Pair<K, V> {
private K key;
private V value;
public Pair(K key, V value) {
this.key = key;
this.value = value;
}
public K getKey() { return key; }
public V getValue() { return value; }
}

通常调用泛型方法的方式如下:

1
2
3
4
5
6
Pair<Integer, String> p1 = new Pair<>(1, "apple");
Pair<Integer, String> p2 = new Pair<>(2, "pear");
boolean same = Util.<Integer, String>compare(p1, p2);
// 如果在 Java 7 以上版本,利用类型推断可以简写为
boolean same = Util.compare(p1, p2);

3. 有界类型参数 (Bounded Type Parameters)

很多时候我们都想限制参数类型的边界,例如在对比两个对象的方法中,想确保方法参数都是 Comparable 的。声明有界类型参数(Bounded Type Parameters
),格式为T extends Class & Interface1 & ... & InterfaceN

1
2
3
public static <T extends Comparable<T>> int compare(T t1, T t2){
return t1.compareTo(t2);
}

这样当我们传递的参数没有实现 Comparable 接口,会有编译时错误。有界类型参数同样可以用于泛型类和泛型接口中,而且支持多个边界,例如 <T extends A & B & C>,只允许最多一个 Class 边界,而且如果有一个 Class 边界,Class 边界必须在最前面。

4. 通配符

Java 泛型中问号?是通配符,表示未知类型。通配符可以用于参数、属性、局部变量或返回值的类型,但是不能用于泛型方法调用或创建泛型类实例的类型参数。

4.1 无界通配符 (Unbounded Wildcards)

单独使用?表示无界通配符,例如List<?>,表示未知类型的 list。下面两个场景适合使用无界通配符:

  • 如果想写一个方法,只用到 Object 类中的功能,即用List<?>代替List<Object>

  • 当使用到的泛型类型的方法不依赖参数类型时,例如只用到 List.size 或 List.clear 方法。事实上,Class<?>非常常见也是因为Class<T>中的大多数方法都不依赖 T。

4.2 上界通配符 (Upper Bounded Wildcards)

上界通配符可以放宽对变量的限制。语法为? extends SuperType,SuperType 可以是类或接口。例如,如果想写一个对 List<Integer>, List<Double>, List<Number>都适用的方法,可以用 List<? extends Number>

1
2
3
4
5
6
public static double sumOfList(List<? extends Number> list) {
double s = 0.0;
for (Number n : list)
s += n.doubleValue();
return s;
}

4.3 下界通配符 (Lower Bounded Wildcards)

下界通配符可以限制为特定类型或该类型的父类型。语法为? super SubType。例如,想写一个方法添加 Integer 对象到 list 中,可以是 List<Integer>, List<Number>List<Object>,可以用List<? super Integer>

1
2
3
4
5
public static void addNumbers(List<? super Integer> list) {
for (int i = 1; i <= 10; i++) {
list.add(i);
}
}

4.4 泛型的继承与子类型

泛型有个常见的误解:Integer 是 Number 的子类型,所以 Box<Integer> 也是 Box<Number> 的子类型。但是其实Box<Integer>Box<Number>并没有直接关系。

1
2
public void boxTest(Box<Number> n) { /* ... */ }
// 如果传 Box<Integer> 会出现编译错误

泛型类的继承,可以看 Collection 的关系,ArrayList<String>List<String>的子类型:

上面提到Box<Integer>Box<Number>都是 Object 子类,但是它们还有个共有的父类型Box<?>,同理List<Number>List<Integer>的父类型为List<?>

至于上界通配符和下界通配符间的关系,见下图:

4.5 通配符捕获 (Wildcard Capture)

有些时候,编译器会推测通配符的类型,例如List<?>类型,在某些代码中编译器从代码推断出具体的类型,这种场景就是通配符捕获。大多数情况下,我们都不需要关心通配符捕获,除非看到错误信息中包含“CAP#”。

下面代码会产生捕获错误:

1
2
3
4
5
public class WildcardError {
void foo(List<?> i) {
i.set(0, i.get(0)); // 错误: 不兼容的类型: Object无法转换为CAP#1
}
}

上面代码中的错误一开始可能觉得莫名其妙,先看看错误信息:i.set(int, capture<?>) 需要的参数类型为int,CAP#1,而实际传入的为int,Object,编译器将 i.get(0) 返回的类型推断为 Object。当调用List.set(int, E)时,编译器无法确认传入的类型与 List 的元素类型一致,虽然我们人为知道这处调用的类型是一致的。

我们可以额外加一个泛型方法来避免编译错误:

1
2
3
4
5
6
7
8
9
10
11
public class WildcardFixed {
void foo(List<?> i) {
fooHelper(i);
}
// Helper method created so that the wildcard can be captured
// through type inference.
private <T> void fooHelper(List<T> l) {
l.set(0, l.get(0)); // 传入参数也为 T,编译器推断为 CAP#1
}
}

下面再看一个更复杂的例子:

1
2
3
4
5
6
7
public class WildcardErrorBad {
void swapFirst(List<? extends Number> l1, List<? extends Number> l2) {
Number temp = l1.get(0);
l1.set(0, l2.get(0)); // 错误: 不兼容的类型: Number无法转换为CAP#1
l2.set(0, temp); // 错误: 不兼容的类型: Number无法转换为CAP#1
}
}

这个例子试图执行一个不安全的操作,看下面调用的场景:

1
2
3
List<Integer> li = Arrays.asList(1, 2, 3);
List<Double> ld = Arrays.asList(10.10, 20.20, 30.30);
swapFirst(li, ld);

虽然List<Integer>List<Double>都符合List<? extends Number>类型,但是List<Integer>列表中存放 Double 类型的元素显然不正确,所以也无法添加其他泛型方法来解决这个问题。

4.6 PECS 原则

在学习泛型的过程,一个容易困惑的问题是如何什么时候用上界通配符或下界通配符。下面先分析两者的具体使用区别。

对于List<? extends Number>类型,可以执行哪些操作呢?

1
2
3
4
5
6
7
8
List<? extends Number> list = new ArrayList<Integer>();
Number first = list.get(0); // OK
list.add(null); // OK
Number number = 1;
list.add(number); // 错误: 不兼容的类型: Number无法转换为CAP#1
list.clear(); // OK
list.remove(0); // OK

List<? extends Number>类型可以添加 null 值,也可以通过泛型方法写入从本身 list 读取的值,但是无法添加新的元素。无法添加新元素的原因,是对于List<? extends Number>类型来说,可能是 List<Number>List<Integer>List<Double>等类型,无法确定新元素的类型与集合里的类型一致,所以编译器会提示报错。所以可以将List<? extends Number>类型的列表看作非严格意义上的只读列表。

而对于List<? super Number>类型呢:

1
2
3
4
5
6
7
8
List<? super Number> list = new ArrayList<Object>();
Number first = list.get(0); // 错误: 不兼容的类型: CAP#1无法转换为Number
list.add(null); // OK
Number number = 1;
list.add(number); // OK
list.clear(); // OK
list.remove(0); // OK

List<? super Number>类型可以添加 null 值、添加新的元素,也可以删除元素,但是无法读取列表中的值。无法读取列表的原因,是对于List<? super Number>类型来说,可能是List<Number>也可能是List<Object>类型,读取列表元素时不能确定元素类型。所以可以将List<? super Number>类型的列表看作只写列表。

上面两个例子中,只读类型相当于生产者(Producer),生产 T,就使用? extends T,只写类型相当于消费者(Consumer),消费 T,就使用? super T。也就是“Producer Extends, Consumer Super”,简称 PECS 原则。

Collections.copy 方法就用到了这个原则,copy(List<? super T> dest, List<? extends T> src),src 列表是只读的,dest 列表是只写的。

通配符的使用建议如下:

  • 只读类型使用上界通配符? extends T

  • 只写类型使用下界通配符? super T

  • 如果只读类型只用到 Object 的方法,即List<? extends Object>,可以用List<?>无界通配符

  • 对于同时需要读取和写入的类型,不要使用通配符

上面四条建议都不适用于方法返回值类型。应该避免在返回值中使用通配符,因为这样会强制要求调用者调用时处理通配符。

5. 类型擦除

类型擦除是 Java 泛型中最容易产生困惑的地方,举个很简单的例子,许多人误以为List<String>List<Integer>的 Class 类型不一致:

1
2
3
4
5
List<String> strList = new ArrayList<>();
List<Integer> intList = new ArrayList<>();
System.out.println(strList.getClass().getName()); // java.util.ArrayList
System.out.println(intList.getClass().getName()); // java.util.ArrayList
System.out.println(strList.getClass() == intList.getClass()); // true

在编译时List<String>List<Integer>的类型是不一样的,但是在运行时两者的类型又是一样的,背后的原因就是类型擦除。

Java 泛型添加是为了提供编译时的类型检查和支持泛型编程,并没有运行时的支持。所以 Java 编译器会用类型擦除来删除所有泛型类型检查代码,并在必要时插入强制类型转换。类型擦除确保不为参数化类型创建新类,所以ArrayList<E>的 Class 类型还是java.util.ArrayList,相应的,泛型也不会增加运行时开销。Java 编译器在应用泛型类型擦除时有以下行为:

  • 将泛型中所有参数化类型替换为泛型边界,如果参数化类型是无界的,则替换为 Object 类型。字节码中没有任何泛型的相关信息。

  • 为了类型安全,在必要时插入类型转换代码。

  • 生成桥接方法来保持泛型类型的多态性。

5.1 参数化类型替换

对于无解参数化类型,类型擦除时会替换为 Object。

下面看单链表中节点类:

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Node<T> {
private T data;
private Node<T> next;
public Node(T data, Node<T> next) {
this.data = data;
this.next = next;
}
public T getData() { return data; }
// ...
}

经过类型擦除后:

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Node {
private Object data;
private Node next;
public Node(Object data, Node next) {
this.data = data;
this.next = next;
}
public Object getData() { return data; }
// ...
}

对于有界参数化类型,类型擦除时会替换为第一个边界。

如果节点类使用有界参数化类型:

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Node<T extends Comparable<T>> {
private T data;
private Node<T> next;
public Node(T data, Node<T> next) {
this.data = data;
this.next = next;
}
public T getData() { return data; }
// ...
}

经过类型擦除后:

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Node {
private Comparable data;
private Node next;
public Node(Comparable data, Node next) {
this.data = data;
this.next = next;
}
public Comparable getData() { return data; }
// ...
}

5.2 类型转换

经过参数化类型替换后,在使用泛型相关内容时,通常需要添加类型转换代码,看下面代码:

1
2
Node<String> node = new Node<>("Hello", null);
String data = node.getData(); // 实际上 node.getData() 返回的是 Object 类型

所以编译器还会插入类型转换代码,编译后如下:

1
2
Node node = new Node("Hello", null);
String data = (String) node.getData();

5.3 桥接方法

当编译一个类继承泛型类或泛型接口,在类型擦除的过程中编译器会生成一个合成方法,也称为桥接方法。

看下面代码:

1
2
3
4
5
6
7
8
9
interface Comparable <A> {
public int compareTo( A that);
}
final class NumericValue implements Comparable <NumericValue> {
priva te byte value;
public NumericValue (byte value) { this.value = value; }
public byte getValue() { return value; }
public int compareTo( NumericValue t hat) { return this.value - that.value; }
}

经过参数化类型替换后,Comparable 接口的 compareTo 方法的参数类型为 Object,而 NumericValue 也需要实现compareTo(Object)方法,经过类型擦除后:

1
2
3
4
5
6
7
8
9
10
11
12
interface Comparable {
public int compareTo( Object that);
}
final class NumericValue implements Comparable {
priva te byte value;
public NumericValue (byte value) { this.value = value; }
public byte getValue() { return value; }
public int compareTo( NumericValue t hat) { return this.value - that.value; }
// 新合成的桥接方法
public int compareTo(Object that) { return this.compareTo((NumericValue)that); }
}

类型擦除后NumericValue.compareTo(NumericValue)方法不再是接口的实现方法,这是类型擦除的一个副作用:两个方法(在接口和实现类中)在类型擦除之前具有相同的签名,而在类型擦除之后具有不同的签名。

为了让 NumericValue 依然正确地实现 Comparable 接口,编译器添加了一个桥接方法,和接口的签名相同,桥接方法委托给实现类中的原始方法。

虽然存在桥接方法,但是一般情况下,编译器不允许我们调用桥接方法:

1
2
3
NumericValue value = new NumericValue((byte) 0);
value.compareTo(value); // OK
value.compareTo("abc"); // error

但是,还有两种方式可以调用桥接方法:使用原始类型(Raw Types)或反射。但是桥接方法中有类型转换,所以传其他类型会有运行时报错。下面是使用原始类型的例子:

1
2
3
Comparable comparable = new NumericValue((byte) 0);
comparable.compareTo(comparable); // OK
comparable.compareTo("abc"); // OK at compile time, throws ClassCastException at run time

6. 泛型的限制

6.1 不能用基本类型实例化泛型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Pair<K, V> {
private K key;
private V value;
public Pair(K key, V value) {
this.key = key;
this.value = value;
}
// ...
}
Pair<int, char> p = new Pair<>(8, 'a'); // compile-time error
Pair<Integer, Character> p = new Pair<>(8, 'a'); // ok,because of autoboxing

6.2 不能创建参数化类型的实例

不能创建参数化类型的实例,但是可以用反射创建:

1
2
3
4
5
public static <E> void append(List<E> list, Class<E> cls) throws Exception {
E e1 = new E(); // error
E e2 = cls.newInstance(); // ok
list.add(e2);
}

6.3 不能将静态属性声明为泛型类型

类的静态属性是类级别的属性,被该类所有实例共享,所以不允许静态属性是参数化类型:

1
2
3
public class MobileDevice<T> {
private static T os; // compile-time error, if has MobileDevice<Phone> and MobileDevice<Pc> instance, can not confirm the type of os.
}

6.4 不能对参数化类型使用 Casts 或 instanceof

不能 Casts 为参数化类型,除非是无界通配符类型:

1
2
3
List<Integer> li = new ArrayList<>();
List<?> list = li;
List<Number> ln = (List<Number>) li; // compile-time error

但是有些场景,编译器知道参数化类型是合法的,也会运行类型转换:

1
2
List<String> l1 = new ArrayList<>();
ArrayList<String> l2 = (ArrayList<String>)l1; // OK

因为类型擦除,无法确定运行时参数化类型具体是什么类型,所以无法使用 instanceof 校验类型:

1
2
3
4
5
6
7
8
public static <E> void rtti(List<E> list) {
if (list instanceof ArrayList<Integer>) { // compile-time error
// ...
}
if (list instanceof ArrayList<?>) { // OK; instanceof requires a reifiable type
// ...
}
}

6.5 不能创建参数化类型的数组

1
ArrayList<String>[] arrayOfList = new ArrayList<String>[3]; // compile-time error

6.6 不能创建、捕捉或抛出参数化类型的对象

泛型类不能直接或间接地继承Throwable类:

1
2
3
4
5
// Extends Throwable indirectly
class MathException<T> extends Exception { /* ... */ } // compile-time error
// Extends Throwable directly
class QueueFullException<T> extends Throwable { /* ... */ } // compile-time error

也无法捕捉参数化类型的异常:

1
2
3
4
5
6
7
8
public static <T extends Exception, J> void execute(List<J> jobs) {
try {
for (J job : jobs)
// ...
} catch (T e) { // compile-time error
// ...
}
}

但是,可以在 throws 语句中使用参数化类型:

1
2
3
4
5
class Parser<T extends Exception> {
public void parse(File file) throws T { // OK
// ...
}
}

6.7 不能重载参数类型为相同原始类型的方法

不能有两个重载方法,当他们的方法签名在类型擦除后是一样的。

1
2
3
4
public class Example {
public void print(List<String> list) {}
public void print(List<Integer> list) {}
}

7. 小结

Java 泛型的重点是:泛型只是编译时的,在编译后会执行类型擦除,这是对 Java 泛型容易误解的地方。而对于通配符,牢记 PECS 原则:生产者 - Extends,消费者 - Super。

推荐阅读:

END
Johnny Shieh wechat
我的公众号,不只有技术,还有咖啡和彩蛋!