Java 泛型总结（一）：基本用法与类型擦除

简介

java 在 1.5 引入了泛型机制，泛型本质是参数化类型，也就是说变量的类型是一个参数，在使用时再指定为具体类型。泛型可以用于类、接口、方法，通过使用泛型可以使代码更简单、安全。然而 java 中的泛型使用了类型擦除，所以只是伪泛型。这篇文章对泛型的使用以及存在的问题做个总结，主要参考自 《java 编程思想》。

这个系列的另外两篇文章：

• java 泛型总结（二）：泛型与数组
• java 泛型总结（三）：通配符的使用

基本用法

泛型类

如果有一个类 holder 用于包装一个变量，这个变量的类型可能是任意的，怎么编写 holder 呢？在没有泛型之前可以这样：

public class holder1 {
 private object a;
 public holder1(object a) {
 this.a = a;
 }
 public void set(object a) {
 this.a = a;
 }
 public object get(){
 return a;
 }
 public static void main(string[] args) {
 holder1 holder1 = new holder1("not generic");
 string s = (string) holder1.get();
 holder1.set(1);
 integer x = (integer) holder1.get();
 }
}

在 holder1 中，有一个用 object 引用的变量。因为任何类型都可以向上转型为 object，所以这个 holder 可以接受任何类型。在取出的时候 holder 只知道它保存的是一个 object 对象，所以要强制转换为对应的类型。在 main 方法中， holder1 先是保存了一个字符串，也就是 string 对象，接着又变为保存一个 integer 对象(参数 1 会自动装箱)。从 holder 中取出变量时强制转换已经比较麻烦，这里还要记住不同的类型，要是转错了就会出现运行时异常。

下面看看 holder 的泛型版本：

public class holder2<t> {
 private t a;
 public holder2(t a) {
 this.a = a;
 }
 public t get() {
 return a;
 }
 public void set(t a) {
 this.a = a;
 }
 public static void main(string[] args) {
 holder2<string> holder2 = new holder2<>("generic");
 string s = holder2.get();
 holder2.set("test");
 holder2.set(1);//无法编译 参数 1 不是 string 类型
 }
}

在 holder2 中， 变量 a 是一个参数化类型 t，t 只是一个标识，用其它字母也是可以的。创建 holder2 对象的时候，在尖括号中传入了参数 t 的类型，那么在这个对象中，所有出现 t 的地方相当于都用 string 替换了。现在的 get 的取出来的不是 object ，而是 string 对象，因此不需要类型转换。另外，当调用 set 时，只能传入 string 类型，否则编译无法通过。这就保证了 holder2 中的类型安全，避免由于不小心传入错误的类型。

通过上面的例子可以看出泛使得代码更简便、安全。引入泛型之后，java 库的一些类，比如常用的容器类也被改写为支持泛型，我们使用的时候都会传入参数类型，如：arraylist<integer> list = arraylist<>();。

泛型方法

泛型不仅可以针对类，还可以单独使某个方法是泛型的，举个例子：

public class genericmethod {
 public <k,v> void f(k k,v v) {
 system.out.println(k.getclass().getsimplename());
 system.out.println(v.getclass().getsimplename());
 }
 public static void main(string[] args) {
 genericmethod gm = new genericmethod();
 gm.f(new integer(0),new string("generic"));
 }
}

代码输出：
 integer
 string

genericmethod 类本身不是泛型的，创建它的对象的时候不需要传入泛型参数，但是它的方法 f 是泛型方法。在返回类型之前是它的参数标识 <k,v>，注意这里有两个泛型参数，所以泛型参数可以有多个。

调用泛型方法时可以不显式传入泛型参数，上面的调用就没有。这是因为编译器会使用参数类型推断，根据传入的实参的类型 (这里是 integer 和 string) 推断出 k 和 v 的类型。

类型擦除

什么是类型擦除

java 的泛型使用了类型擦除机制，这个引来了很大的争议，以至于 java 的泛型功能受到限制，只能说是”伪泛型“。什么叫类型擦除呢？简单的说就是，类型参数只存在于编译期，在运行时，java 的虚拟机 ( jvm ) 并不知道泛型的存在。先看个例子：

public class erasedtypeequivalence {
 public static void main(string[] args) {
 class c1 = new arraylist<string>().getclass();
 class c2 = new arraylist<integer>().getclass();
 system.out.println(c1 == c2);
 }
}

上面的代码有两个不同的 arraylist：arraylist<integer> 和 arraylist<string>。在我们看来它们的参数化类型不同，一个保存整性，一个保存字符串。但是通过比较它们的 class 对象，上面的代码输出是 true。这说明在 jvm 看来它们是同一个类。而在 c++、c# 这些支持真泛型的语言中，它们就是不同的类。

泛型参数会擦除到它的第一个边界，比如说上面的 holder2 类，参数类型是一个单独的 t，那么就擦除到 object,相当于所有出现 t 的地方都用 object 替换。所以在 jvm 看来，保存的变量 a 还是 object 类型。之所以取出来自动就是我们传入的参数类型，这是因为编译器在编译生成的字节码文件中插入了类型转换的代码，不需要我们手动转型了。如果参数类型有边界那么就擦除到它的第一个边界，这个下一节再说。

擦除带来的问题

擦除会出现一些问题，下面是一个例子：

class hasf {
 public void f() {
 system.out.println("hasf.f()");
 }
}
public class manipulator<t> {
 private t obj;
 public manipulator(t obj) {
 this.obj = obj;
 }
 public void manipulate() {
 obj.f(); //无法编译 找不到符号 f()
 }
 public static void main(string[] args) {
 hasf hasf = new hasf();
 manipulator<hasf> manipulator = new manipulator<>(hasf);
 manipulator.manipulate();
 }
}

上面的 manipulator 是一个泛型类，内部用一个泛型化的变量 obj，在 manipulate 方法中，调用了 obj 的方法 f()，但是这行代码无法编译。因为类型擦除，编译器不确定 obj 是否有 f() 方法。解决这个问题的方法是给 t 一个边界:

class manipulator2<t extends hasf> {
 private t obj;
 public manipulator2(t x) { obj = x; }
 public void manipulate() { obj.f(); }
}

现在 t 的类型是 <t extends hasf>，这表示 t 必须是 hasf 或者 hasf 的导出类型。这样，调用 f() 方法才安全。hasf 就是 t 的边界，因此通过类型擦除后，所有出现 t 的

地方都用 hasf 替换。这样编译器就知道 obj 是有方法 f() 的。

但是这样就抵消了泛型带来的好处，上面的类完全可以改成这样：

class manipulator3 {
 private hasf obj;
 public manipulator3(hasf x) { obj = x; }
 public void manipulate() { obj.f(); }
}

所以泛型只有在比较复杂的类中才体现出作用。但是像 <t extends hasf> 这种形式的东西不是完全没有意义的。如果类中有一个返回 t 类型的方法，泛型就有用了，因为这样会返回准确类型。比如下面的例子：

class returngenerictype<t extends hasf> {
 private t obj;
 public returngenerictype(t x) { obj = x; }
 public t get() { return obj; }
}

这里的 get() 方法返回的是泛型参数的准确类型，而不是 hasf。

类型擦除的补偿

类型擦除导致泛型丧失了一些功能，任何在运行期需要知道确切类型的代码都无法工作。比如下面的例子：

public class erased<t> {
 private final int size = 100;
 public static void f(object arg) {
 if(arg instanceof t) {} // error
 t var = new t(); // error
 t[] array = new t[size]; // error
 t[] array = (t)new object[size]; // unchecked warning
 }
}

通过 new t() 创建对象是不行的，一是由于类型擦除，二是由于编译器不知道 t 是否有默认的构造器。一种解决的办法是传递一个工厂对象并且通过它创建新的实例。

interface factoryi<t> {
 t create();
}
class foo2<t> {
 private t x;
 public <f extends factoryi<t>> foo2(f factory) {
 x = factory.create();
 }
 // ...
}
class integerfactory implements factoryi<integer> {
 public integer create() {
 return new integer(0);
 }
}
class widget {
 public static class factory implements factoryi<widget> {
 public widget create() {
 return new widget();
 }
 }
}
public class factoryconstraint {
 public static void main(string[] args) {
 new foo2<integer>(new integerfactory());
 new foo2<widget>(new widget.factory());
 }
}

另一种解决的方法是利用模板设计模式：

abstract class genericwithcreate<t> {
 final t element;
 genericwithcreate() { element = create(); }
 abstract t create();
}
class x {}
class creator extends genericwithcreate<x> {
 x create() { return new x(); }
 void f() {
 system.out.println(element.getclass().getsimplename());
 }
}
public class creatorgeneric {
 public static void main(string[] args) {
 creator c = new creator();
 c.f();
 }
}

具体类型的创建放到了子类继承父类时，在 create 方法中创建实际的类型并返回。

总结

本文介绍了 java 泛型的使用，以及类型擦除相关的问题。一般情况下泛型的使用比较简单，但是某些情况下，尤其是自己编写使用泛型的类或者方法时要注意类型擦除的问题。接下来会介绍以及。

以上就是本文的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，同时也希望多多支持！