Java泛型的介绍与使用

谁践踏了优雅 2022-09-29 14:58 75阅读 0赞

# 一、基本概念 #

“泛型编程”这个概念最早就是来源于C++当初设计STL时所引入的模板（Template），而为什么要引入模板呢，因为STL要完成这样一个目标：**设计一套通用的，不依赖类型的，高效的的算法（例如std::sort）和数据结构**（例如std::list）。**关于通用性，运行时多态可以做到（例如很多高级语言的继承（机制，接口机制）**，但是C++作为一门相对底层的语言，对运行效率的要求是很严格的，而**运行时多态会影响效率**（例如成员函数只有在运行时才知道调用哪个），所以设计STL的人就创造了**一种编译时多态技术，即模板**。

那什么又是编译时多态呢，简单点说就是**让编译器帮我确定类型**，我写程序时只要**标记下这里我要用“某种类型”的对象**，至于具体是什么类型我不关心，编译器帮我确定，**编译完成后，在运行时类型是绝对确定的**，这样就大大提高了运行效率，反之对编译器来说，就增加了很多工作，而且生成的目标代码也会大大增加。所以对C++来说，所谓“泛型（Generics）”，并不是说编译器不知道类型，而是针对程序员来说的，这也正是通用性的体现。

二、为什么Java需要泛型

首先，我们看下下面这段简短的代码：

public class GenericTest {
    	public static void main(String[] args) {
    		List list = new ArrayList();
    		list.add("qqyumidi");
    		list.add("corn");
    		list.add(100);
    		for (int i = 0; i < list.size(); i++) {
    			String name = (String) list.get(i);		// 1
    			System.out.println("name:" + name);
    		}
    	}
    }

代码定义了一个List类型的集合，先向其中加入了两个String类型的值，随后加入一个Integer类型的值。这是完全允许的，因为**此时list默认的类型为Object类型**。在之后的循环中，由于忘记了之前在list中加入了Integer类型的值或其他编码原因，很容易出现类似于//1中的错误。这段语句在编译阶段正常，而运行时会出现“Java.lang.ClassCastException”异常。因此，导致此类错误编码过程中不易发现。在如上的编码过程中，我们发现主要存在两个问题：

1）当我们将一个对象放入集合中，集合不会记住此对象的类型，当**再次从集合中取出此对象时，该对象的编译类型变成了Object类型**，**但运行时类型转换为其本身类型**。

2）取出集合元素时需要人为的强制类型转化到具体的目标类型，且很容易出现“Java.lang.ClassCastException”异常。

那么有没有什么办法可以**使集合能够记住集合内元素各类型，且能够达到只要编译时不出现问题**，运行时就不会出现“Java.lang.ClassCastException”异常呢？答案就是使用泛型。

# 三、Java泛型怎么用 #

**（1）定义泛型类**

我们定义一个Person1类，包含三个属性x，y，z。在我们开始定义地时候，我们也不知道这三个属性是用来干什么的，所以我们定义为Object类型。但是在使用的时候，我们分别对x，y，z赋予了int，double，String类型，所以在取出的时候，我们需要把这三个类型值进行强制转换。同时，再定义一个泛型类Person2，定义三个属性x，y，z，在测试类中，我们设置属性的值，并打印属性的值，代码如下：

class Person1 {
    	private Object x;
    	private Object y;
    	private Object z;
    	//使用Object类型。可以转化为任何类型
    	public Object getX() {
    		return x;
    	}
    	public void setX(Object x) {
    		this.x = x;
    	}
    	public Object getY() {
    		return y;
    	}	
    	public void setY(Object y) {
    		this.y = y;
    	}
    	public Object getZ() {
    		return z;
    	}
    	public void setZ(Object z) {
    		this.z = z;
    	}
    }
    class Person2<T> 
    {
    	private T x;
    	private T y;
    	private T z;
    	public T getX() {
    		return x;
    	}
    	public void setX(T x) {
    		this.x = x;
    	}
    	public T getY() {
    		return y;
    	}	
    	public void setY(T y) {
    		this.y = y;
    	}
    	public T getZ() {
    		return z;
    	}
    	public void setZ(T z) {
    		this.z = z;
    	}
    }
    public class PersonTest 
    {
    	public static void main(String[]args)
    	{
    		Person1 boy1 = new Person1();
    		boy1.setX(20);
    		boy1.setY(22.2);
    		boy1.setZ("帅哥TT");
    		//取出属性值时，需要进行类型转化
    		System.out.println((Integer)boy1.getX());
    		System.out.println((Double)boy1.getY());
    		System.out.println((String)boy1.getZ());
    		//下面是使用泛型后的代码
    		Person2 boy2=new Person2();
    		boy2.setX(20);
    		boy2.setY(22.2);
    		boy2.setZ("帅哥TT");
    		//这里程序员不需要手工类型转化
    		//但实际上，由于类型擦除，类型转换将由编译器自动执行
    		System.out.println(boy2.getX());
    		System.out.println(boy2.getY());
    		System.out.println(boy2.getZ());
    	}
    }

**（2）类型变量的限定**

如下代码，我们在方法min中定义了一个变量smallest类型为T，这说明了smallest可以是任何一个类的对象，我们在下面的代码中**需要使用compareTo方法， 但是我们没有办法确定我们的T中含有CompareTo方法，所以我们需要对T进行限定**，在代码中我们让T继承Comparable类。如下：

public static<T extends Comparable>T min(T[]a)//泛型方法

测试代码：

public class Person{
    	public static<T extends Comparable>T min(T[]a){
    		if(a==null||a.length==0){
    			return null;
    		}
    		T smallest=a[0];
    		for(int i=1;i<a.length;i++){
    			if(smallest.compareTo(a[i])>0){
    				smallest=a[i];
    			}
    		}
    		return smallest;
    	}
    	public static void main(String [] args){
    		Integer[]num={20,25,30,10};
    		Integer smallest =Person.<Integer>min(num);
    		System.out.println(smallest);
    	}
    }

**（3）定义泛型接口**

public interface Person<T1,T2> {
    	public T1 getX();
    	public T2 getY();
    }

**（4）定义泛型方法**

**    必须在方法的返回值前边加一个<T>，来声明这是一个泛型方法**，持有一个泛型T，然后才可以用泛型T作为方法的返回值。

public class Person{
    	public static<T>T getMiddle(T[]a)
    	{
    		return a[a.length >> 1];
    	}
    	public static void main(String [] args)
    	{
    		String[]name={"帅哥TT","帅哥TT1","帅哥TT2"};
    		String middle=Person.<String>getMiddle(name);
    		System.out.println(middle);
    		Integer[]num={20,22,25};
    		Integer middle1=Person.<Integer>getMiddle(num);
    		System.out.println(middle1);
    	}
    }

**（5）类型通配符**

我们知道，由于类型擦除，Box<Number>与Box<Integer>实际上都是Box类型，ArrayList<Manager>与ArrayList<Employee>实际上都是ArrayList类型，现在需要继续探讨一个问题，那么在逻辑上，类似于Box<Number>与Box<Integer>、ArrayList<Manager>与ArrayList<Employee>是否可以看成具有父子关系的泛型类型呢？

为了弄清这个问题，我们继续看下面这个例子：

class Box<T> {
    	private T data;
    	public Box(T data){
    		this.data = data;
    	}
    	public T getData(){
    		return data;
    	}
    }
    public class BoxTest {
    	public static void main(String[] args){
    		Box<Number> name = new Box<Number>(99);
    		Box<Integer> age = new Box<Integer>(712);
    		System.out.println("name class:" + name.getClass());
    		System.out.println("age class:" + age.getClass());
    		System.out.println("Box class:" + Box.class);
    		getData(name);
    		getData(age);		//1		编译错误
    	}
    	public static void getData(Box<Number> data){
    		System.out.println("data:" + data.getData());
    	}
    }

这个例子中，显然//1处会出现错误提示的。我们知道Box<Number>逻辑上不能视为Box<Integer>的父类。那么如何解决呢？总不能再定义一个新的函数吧。这和Java中的多态理念显然是违背的，因此，我们需要一个在逻辑上可以用来表示同时是Box<Integer>和Box<Number>的父类的一个引用类型，由此，类型通配符应运而生。

类型通配符一般是**使用?代替具体的类型实参**。注意了，此处是类型实参，而不是类型形参！且**Box<?>在逻辑上是Box<Integer>、Box<Number>...等所有Box<具体类型实参>的父类**。由此，我们将getData函数的代码修改成如下即可。

public static void getData(Box<?> data){
    	System.out.println("data:" + data.getData());
    }

有时候，我们还可能听到类型通配符上限和类型通配符下限。具体有是怎么样的呢？在上面的例子中，如果需要定义一个功能类似于getData()的方法，但**对类型实参又有进一步的限制**：**只能是Number类及其子类**。此时，需要用到类型通配符上限。

public static void getUpperData(Box<? extends Number> data){
    	System.out.println("data:" + data.getData());
    }

**    类型通配符上限通过形如Box<? extends Number>形式定义**，相对应的，类型通配符**下限为Box<? super Number>形式**，其含义与类型通配符上限正好相反，在此不作过多阐述了。

**（6）类型擦除**

Java中的泛型与C++泛型（模板）有很大不同，那就是“类型擦除”。Java中的类型擦除并不是一个语言特性。泛型不是Java语言出现时就有的组成部分，擦除只是Java的泛型实现中的一种折中。《Thinking in Java》一书中的例子很好的展示了擦除是什么：

import java.util.*;
    public class Erase {
    		public static void main(String[] args) {
    		// TODO code application logic here
    		Class c1 = new ArrayList<String>().getClass();
    		Class c2 = new ArrayList<Integer>().getClass();
    		System.out.println(c1 == c2);
    	}
    }

结果输出是true

ArrayList<String>和ArrayList<Interger>很容易认为是不同的类型。不同的类型在行为方面肯定不同，但上面的程序认为它们是相同的类型。原因就是Java的泛型是使用擦除来实现的，这意味着当你使用泛型时，任何具体的类型信息都被擦除了，你唯一知道的就是你在使用一个对象。因此List<String>和List<Interger>在运行时事实上是相同的类型，这两种形式都被擦除成它们的“原生”类型，即List。类型擦除导致的残酷现实是：**在泛型代码内部，无法获得任何有关泛型参数类型的信息（Thinking in Java)。**擦除丢失了在泛型代码中执行某些操作的能力，任何**在运行时需要知道确切类型信息的操作**都将无法工作。

public class Erased<T> {
    	private static  final int SIZE = 100;
    	public void test(){
    		//编译错误1
    		if(arg instanceof T) {}  
    		//编译错误2
    		T var = new T();      
    		//编译错误3
    		T[] array = new T[SIZE];      
    		// 编译会发生警告
    		T[] array1 = (T[])new Object[SIZE];
    	}
    }

现在我们都知道擦除会丢失了在泛型代码中执行某些操作的能力，这将会使任何确切类型信息的操作都将会无法工作，但有时必须通过引入类型标签对擦除进行补偿，这意味着你需要显示的传递你的类型的Class对象，以便你可以在类型表达式中使用它。

对于以上代码中的“编译错误1”,解决方案如下：

public class ClassTypeCapture<T> {
    	Class<T> kind;
    	public ClassTypeCapture(Class<T> kind) {
    		this.kind = kind;
    	}
    	public boolean f(Object arg) {
    		//只要对象是kind的自身实例或其子类实例，就返回true
    		return kind.isInstance(arg);
    	} 
    	public static void main(String[] args) {
    		ClassTypeCapture<String> ctt1 = new ClassTypeCapture<String>(String.class);
    		System.out.println(ctt1.f(new String()));
    		System.out.println(ctt1.f(new Integer(2)));
    		ClassTypeCapture<Integer> ctt2 = new ClassTypeCapture<Integer>(Integer.class);
    		System.out.println(ctt2.f(new String()));
    		System.out.println(ctt2.f(new Integer(2)));
    	}
    }

运行结果如下：

true
    false
    false
    true

“编译错误2”表明创建一个new T()的尝试将无法实现，部分原因是因为擦除，另一部分原因是因为编译器不能验证T具有默认（无参）构造函数。但是在C++中，这种操作很自然、很直观，并且很安全（它是在编译期受到检查的）。Java中的解决方案是传递一个工厂对象，并使用它来创建新的实例。最便利的工厂对象就是Class对象，因此如果使用类型标签，那么就可以使用newInstance()来创建这个类型的新对象：

class ClassAsFactory<T>{
    	T x;
    	public ClassAsFactory(Class<T> kind)
    	{
    		try{
    			x = kind.newInstance();
    		} catch(Exception e) {
    			throw new RuntimeException(e);
    		}
    	}
    }
    class Employee {}
    public class InstantiateGenericType{
    	public void main(String[] args){
    		ClassAsFactory<Employee> fe = new ClassAsFactory<Employee>(Employee.class);
    		print(“ClassAsFactory<Employee> succeeded”);
    		try{
    			ClassAsFactory<Integer> fi = new ClassAsFactory<Integer>(Integer.class);
    		} catch(Exception e) {
    			print(“ClassAsFactory<Integer> failed”);
    		}
    	}
    }

运行结果如下：

ClassAsFactory<Employee> succeeded
    ClassAsFactory<Integer> failed

因为Integer没有任何默认的构造器，这个错误是在运行期捕获的。

“编译错误3”表明不能创建泛型数组，一般的解决方案是在任何想要创建泛型数组的地方都使用ArrayList:

import java.util.*;
    public class ListOfGenerics<T> {
    	private List<T> array = new ArrayList<T>();
    	public void add(T item) { array.add(item); }
    	public T get(int index) { return array.get(index); }
    }

看一个更复杂的示例。考虑一个传递一个类型标记的泛型数组包装器：

public class GenericArrayWithTypeToken<T> {
    	private T[] array;
    	@SuppressWarnings("unchecked")
    	public GenericArrayWithTypeToken(Class<T> type, int sz) {
    		array = (T[])Array.newInstance(type, sz);
    	}
    	public void put(int index, T item) {
    		array[index] = item;
    	}
    	public T get(int index) { 
    		return array[index]; 
    	}
    	public T[] rep() { 
    		return array; 
    	}    
    	public static void main(String[] args) {
    		GenericArrayWithTypeToken<Integer> gai = new GenericArrayWithTypeToken<Integer>(Integer.class, 10);
    		Integer[] ia = gai.rep();
    	}
    }

类型标记Class<T>被传递到构造器中，以便从擦除中恢复，使得我们可以创建需要的实际类型的数组，尽管从转型中产生的警告必须用@Suppresswarnings压制住。一旦我们获得了实际类型。就可以返回它，并获得想要的结果，就像在main()中看到的那样。

# 四、Java泛型与C++模板的区别 #

C++的模板会对**针对不同的模板参数静态实例化，目标代码体积会稍大一些，运行速度会快很多**。

C++ template是具体化的泛型，Java的泛型靠的是类型擦除，目标代码只会生成一份，牺牲的是运行速度。

C++在运行时没有额外的开销，Java在**运行时有类型转换的开销**。

C++的每个具体的泛型类型都有一份独立的代码，Java只有一份类型擦除之后的代码，这意味着C++ template编译后会产生代码膨胀而Java泛型不会。

C++的类型检查是在编译时做的，Java的类型检查在编译期和运行期都要做一些工作。

总的来说C++的template会生成更大的二进制代码，但会执行的比较快，但大个的二进制代码可能会导致更多的I/O，所以也不一定完全是优势。

Java生成的代码只有一份，运行时会有一些类型转换的开销，但可以在运行时支持新类型，比如用ClassLoader动态加载进来的类。

Java泛型的实现植根于“类型擦除”这一概念。当源代码被转换成Java虚拟机字节码时，这种技术会消除参数化类型。例如，假设有如下Java代码：

Vector<String> vec = new Vector<String>();
    vec.add(new String(“hello”));
    String str = vec.get(0);

编译时，上面的代码会被改写为：

Vector vec = new Vector();
    vec.add(new String("hello"));
    String str = (String)vec.get(0);		//编译器自动加上类型转换

有了Java泛型，我们可以做的事情也没有真正改变多少；它只是让代码变得漂亮些。这点跟C++截然不同。在C++中，模板本质上是一套宏指令集，只是换了个名头，编译器会针对每种类型创建一份模板代码的副本。有项证据可以证明这一点：MyClass<Foo>不会与MyClass<Bar>共享静态变量。然而，两个MyClass<Foo>实例则会共享静态变量。看了下面的代码，应该会更清楚一点：

/*MyClass.h*/
    template<typename T>
    class MyClass
    {
    	public:
    	static int val;
    	MyClass() {}
    	static void increment()
    	{
    		val += 1;
    	}
    };
    template<typename T>
    int MyClass<T>::val = 0;
    /*main.cpp*/
    int main(void)
    {
    	MyClass<int> foo1;
    	MyClass<int> foo2 ;
    	foo1.increment();
    	foo2.increment();
    	cout << "foo1.val = " << foo1.val << endl;	//2
    	cout << "foo2.val = " << foo2.val << endl;	//2
    	MyClass<double> *bar1 = new MyClass<double>();
    	MyClass<double> *bar2 = new MyClass<double>();
    	bar1->increment();
    	bar2->increment();
    	cout << "barr->val = " << bar1->val << endl;	//2
    	cout << "bar2->val = " << bar2->val << endl;	//2
    	return 0;
    }

在Java中**MyClass类的静态变量会由所有MyClass实例共享，不论类型参数相同与否**。由于架构设计上的差异，在Java中，不管类型参数是什么MyClass的所有实例都是同一类型，类型参数不能用于静态方法和变量，因为它们会被MyClass<Foo>和MyClass<Bar>所共享。在C++中，这些类都是不同的，因此类型参数可以用于静态方法与静态变量。

在C++模板中，编译器根据程序员提供的类型参数来扩充模板，因此，为List<A>生成的C++代码不同于为List<B>生成的代码，List<A>和List<B>实际上是两个不同的类。而**Java中的泛型是用类型擦除实现的语法糖，编译器仅仅对这些类型参数进行擦除和替换。类型ArrayList<Integer>和ArrayList<String>的对象共享相同的类，并且只存在一个ArrayList类**，在编译期类型检查以外，生成目标代码的过程中根本不区分泛型的类型参数。因此在C++中存在**为每个模板的实例化产生不同的类型，这一现象被称为“模板代码膨胀”**，而Java则不存在这个问题的困扰。**Java中虚拟机中没有泛型，只有基本类型和类类型，泛型会被擦除**，一般会修改为Object，如果有限制，例如T extends Comparable，则会被修改为Comparable，同时在必要处插入从Object或者Comparable到给定的类型参数的类型转换而已（因此类型参数不能是int这样的基本类型，C++模板就没这个限制）。而在C++中不能对模板参数的类型加以限制，如果程序员用一个不适当的类型实例化一个模板，将会在模板代码中报告一个错误信息。

C++的模板在刚出来的时候并没有想到会演化成今天这样，其他高级语言（如Java，C\#）也是看到C++模板在使用的时候带给了程序员极大的便利，就考虑支持这样一种功能，但是也仅仅是借用了C++的模板理念，而没有完全照抄模板的实现方法，所以对于大部分程序员来说，只要使用起来差不多，并不关心实现。

最后总结下，**泛型是只是一个概念，具体实现有C++的模板，Java的泛型等，但实现方法大不相同，**只是提供给语言使用者相同的使用方法而已。

# 五、Java泛型总结 #

正确理解Java泛型概念的首要前提是理解类型擦除（type erasure）。**Java中的泛型基本上都是在编译器这个层次来实现的**。在生成的Java字节代码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，**会被编译器在编译的时候去掉,这个过程就称为类型擦除**。如在代码中定义的List<Object>和List<String>等类型，在**编译之后都会变成List**，JVM看到的只是List，而由**泛型附加的类型信息对JVM来说是不可见的**。Java编译器会在编译时尽可能的发现可能出错的地方，但是仍然无法避免在运行时刻出现类型转换异常的情况。

很多泛型的奇怪特性都与这个类型擦除的存在有关，包括：

1）泛型类并没有自己独有的Class类对象。比如并不存在List<String>.class或是List<Integer>.class，而只有List.class。

2）静态变量是被泛型类的所有实例所共享的。对于声明为MyClass<T>的类，访问其中的静态变量的方法仍然是MyClass.myStaticVar。不管是通过new MyClass<String>还是new MyClass<Integer>创建的对象，都是共享一个静态变量。

3）**泛型的类型参数不能用在Java异常处理的catch语句中**。因为**异常处理是由JVM在运行时刻来进行的**。由于类型信息被擦除，JVM是无法区分两个异常类型MyException<String>和MyException<Integer>的。对于JVM来说，它们都是MyException类型的，也就无法执行与异常对应的catch语句。

4）由于擦除丢失了在泛型代码中执行某些操作的能力。任何在运行时需要知道确切类型信息的操作将无法工作。

5）**Java的泛型是停留在编译层的，也就是说JVM在对待泛型数据的时候，依然会把它们看成是Object类型**。只不过在使用这些元素的时候，**JVM会自动帮助开发者进行相应的类型转换**。

在使用Java泛型的时候可以遵循一些基本的原则，从而避免一些问题。

1）在代码中**避免泛型类和原始类型的混用**。比如List<String>和List不应该共同使用。这样会产生一些编译器警告和潜在的运行时异常。当需要利用JDK 5之前开发的遗留代码，而不得不这么做时，也尽可能的隔离相关的代码。

2）在**使用带通配符的泛型类的时候，需要明确通配符所代表的一组类型的概念**。由于具体的类型是未知的，很多操作是不允许的。

3）泛型类最好不要同数组一块使用。你只能创建new List<?>\[10\]这样的数组，无法创建new List<String>\[10\]这样的。这限制了数组的使用能力，而且会带来很多费解的问题。因此，**当需要类似数组的功能时候，使用容器类即可**。

4）不要忽视编译器给出的警告信息。

5）不能用基本类型实例化类型参数。因此没有Pair<double>，只有Pair<Double>。当然其原因是类型擦除。擦除之后，Pair类含有Object类型的域，而Object不能存储double值。