这是弄啥嘞，泛型集合~~~

1．为什么需要泛型

泛型在Java中有很重要的地位，网上很多文章罗列各种理论，不便于理解，本篇将立足于代码介绍、总结了关于泛型的知识。希望能给你带来一些帮助。

先看下面的代码：

1. List list = new ArrayList();
2. list.add("CSDN_SEU_Cavin");
3. list.add(100);
4. for (int i = 0; i < list.size(); i++) {
5. String name = (String) list.get(i); //取出Integer时，运行时出现异常
6. System.out.println("name:" + name);
7. }

本例向list类型集合中加入了一个字符串类型的值和一个Integer类型的值。（这样合法，因为此时list默认的类型为Object类型）。在之后的循环中，由于忘记了之前在list中也加入了Integer类型的值或其他原因，运行时会出现java.lang.ClassCastException异常。为了解决这个问题，泛型应运而生。

2．泛型的使用

Java泛型编程是JDK1.5版本后引入的。泛型让编程人员能够使用类型抽象，通常用于集合里面。

只要在上例中将第1行代码改成如下形式，那么就会在编译list.add(100)时报错。

1. List<String> list = new ArrayList<String>();

通过List<String>，直接限定了list集合中只能含有String类型的元素，从而在上例中的第6行中，无须进行强制类型转换，因为集合能够记住其中元素的类型信息，编译器已经能够确认它是String类型了。

3．泛型只在编译阶段有效

看下面的代码：

1. AyyayList<String> a = new ArrayList<String>();
2. ArrayList b = new ArrayList();
3. Class c1 = a.getClass();
4. Class c2 = b.getClass();
5. System.out.println(a == b); //true

上面程序的输出结果为true。所有反射的操作都是在运行时的，既然为true，就证明了编译之后，程序会采取去泛型化的措施，也就是说Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。

上述结论可通过下面反射的例子来印证：

1. ArrayList<String> a = new ArrayList<String>();
2. a.add("CSDN_SEU_Cavin");
3. Class c = a.getClass();
4. try{
5. Method method = c.getMethod("add",Object.class);
6. method.invoke(a,100);
7. System.out.println(a);
8. }catch(Exception e){
9. e.printStackTrace();
10. }

因为绕过了编译阶段也就绕过了泛型，输出结果为：

1. [CSDN_SEU_Cavin, 100]

4．泛型类和泛型方法

如下，我们看一个泛型类和方法的使用例子，和未使用泛型的使用方法进行了对比，两者输出结果相同，在这里贴出来方便读者体会两者的差异。泛型接口的例子有兴趣可以去找一些资料，这里就不赘述了。

（1）使用泛型的情况

1. public static class FX<T> {
2. private T ob; // 定义泛型成员变量
3. public FX(T ob) {
4. this.ob = ob;
5. }
6. public T getOb() {
7. return ob;
8. }
9. public void showTyep() {
10. System.out.println("T的实际类型是: " + ob.getClass().getName());
11. }
12. }
13. public static void main(String[] args) {
14. FX<Integer> intOb = new FX<Integer>(100);
15. intOb.showTyep();
16. System.out.println("value= " + intOb.getOb());
17. System.out.println("----------------------------------");
18. FX<String> strOb = new FX<String>("CSDN_SEU_Calvin");
19. strOb.showTyep();
20. System.out.println("value= " + strOb.getOb());
21. }

（2）不使用泛型的情况

1. public static class FX {
2. private Object ob; // 定义泛型成员变量
3. public FX(Object ob) {
4. this.ob = ob;
5. }
6. public Object getOb() {
7. return ob;
8. }
9. public void showTyep() {
10. System.out.println("T的实际类型是: " + ob.getClass().getName());
11. }
12. }
13. public static void main(String[] args) {
14. FX intOb = new FX(new Integer(100));
15. intOb.showTyep();
16. System.out.println("value= " + intOb.getOb());
17. System.out.println("----------------------------------");
18. FX strOb = new FX("CSDN_SEU_Calvin");
19. strOb.showTyep();
20. System.out.println("value= " + strOb.getOb());
21. }

输出结果均为：

1. T的实际类型是: java.lang.Integer
2. value= 100
3. ----------------------------------
4. T的实际类型是: java.lang.String
5. value= CSDN_SEU_Calvin

5．通配符

为了引出通配符的概念，先看如下代码：

1. List<Integer> ex_int= new ArrayList<Integer>();
2. List<Number> ex_num = ex_int; //非法的

上述第2行会出现编译错误，因为Integer虽然是Number的子类，但List<Integer>不是List<Number>的子类型。

假定第2行代码没有问题，那么我们可以使用语句ex_num.add(newDouble())在一个List中装入了各种不同类型的子类，这显然是不可以的，因为我们在取出List中的对象时，就分不清楚到底该转型为Integer还是Double了。

因此，我们需要一个在逻辑上可以用来同时表示为List<Integer>和List<Number>的父类的一个引用类型，类型通配符应运而生。在本例中表示为List<?>即可。下面这个例子也说明了这一点，注释已经写的很清楚了。

1. public static void main(String[] args) {
2. FX<Number> ex_num = new FX<Number>(100);
3. FX<Integer> ex_int = new FX<Integer>(200);
4. getData(ex_num);
5. getData(ex_int);//编译错误
6. }
7. public static void getData(FX<Number> temp) { //此行若把Number换为“？”编译通过
8. //do something...
9. }
10. public static class FX<T> {
11. private T ob;
12. public FX(T ob) {
13. this.ob = ob;
14. }
15. }