首先，我们看下下面这段简短的代码:
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类型的集合，先向其中加入了两个字符串类型的值，随后加入一个integer类型的值。这是完全允许的，因为此时list默认的类型为object类型。在之后的循环中，由于忘记了之前在list中也加入了integer类型的值或其他编码原因，很容易出现类似于//1中的错误。因为编译阶段正常，而运行时会出现“java.lang.classcastexception”异常。因此，导致此类错误编码过程中不易发现。
在java se 1.5之前，没有泛型的情况的下，通过对类型object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。
二.什么是泛型？
泛型是java se 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
看着好像有点复杂，首先我们看下上面那个例子采用泛型的写法。
public class generictest { public static void main(string[] args) { /* list list = new arraylist(); list.add("qqyumidi"); list.add("corn"); list.add(100); */ list<string> list = new arraylist<string>(); list.add("qqyumidi"); list.add("corn"); //list.add(100); // 1 提示编译错误 for (int i = 0; i < list.size(); i++) { string name = list.get(i); // 2 system.out.println("name:" + name); } } }
采用泛型写法后，在//1处想加入一个integer类型的对象时会出现编译错误，通过list<string>，直接限定了list集合中只能含有string类型的元素，从而在//2处无须进行强制类型转换，因为此时，集合能够记住元素的类型信息，编译器已经能够确认它是string类型了。
结合上面的泛型定义，我们知道在list<string>中，string是类型实参，也就是说，相应的list接口中肯定含有类型形参。且get()方法的返回结果也直接是此形参类型（也就是对应的传入的类型实参）。下面就来看看list接口的的具体定义：
public interface list<e> extends collection<e> { int size(); boolean isempty(); boolean contains(object o); iterator<e> iterator(); object[] toarray(); <t> t[] toarray(t[] a); boolean add(e e); boolean remove(object o); boolean containsall(collection<?> c); boolean addall(collection<? extends e> c); boolean addall(int index, collection<? extends e> c); boolean removeall(collection<?> c); boolean retainall(collection<?> c); void clear(); boolean equals(object o); int hashcode(); e get(int index); e set(int index, e element); void add(int index, e element); e remove(int index); int indexof(object o); int lastindexof(object o); listiterator<e> listiterator(); listiterator<e> listiterator(int index); list<e> sublist(int fromindex, int toindex); }
我们可以看到，在list接口中采用泛型化定义之后，<e>中的e表示类型形参，可以接收具体的类型实参，并且此接口定义中，凡是出现e的地方均表示相同的接受自外部的类型实参。
自然的，arraylist作为list接口的实现类，其定义形式是：
public class arraylist<e> extends abstractlist<e> implements list<e>, randomaccess, cloneable, java.io.serializable { public boolean add(e e) { ensurecapacityinternal(size + 1); // increments modcount!! elementdata[size++] = e; return true; } public e get(int index) { rangecheck(index); checkforcomodification(); return arraylist.this.elementdata(offset + index); } //...省略掉其他具体的定义过程 }
由此，我们从源代码角度明白了为什么//1处加入integer类型对象编译错误，且//2处get()到的类型直接就是string类型了。
三. 什么是元组类库，怎么用？
为什么使用元组tuple？
元组和列表list一样，都可能用于数据存储，包含多个数据；但是和列表不同的是：列表只能存储相同的数据类型，而元组不一样，它可以存储不同的数据类型，比如同时存储int、string、list等，并且可以根据需求无限扩展。
比如说在web应用中，经常会遇到一个问题就是数据分页问题，查询分页需要包含几点信息：当前页数、页大小；查询结果返回数据为：当前页的数据记录，但是如果需要在前台显示当前页、页大小、总页数等信息的时候，就必须有另外一个信息就是：数据记录总数，然后根据上面的信息进行计算得到总页数等信息。这个时候查询某一页信息的时候需要返回两个数据类型，一个是list（当前也的数据记录），一个是int（记录总数）。当然，完全可以在两个方法、两次数据库连接中得到这两个值。事实上在查询list的时候，已经通过sql查询得到总计录数，如果再开一个方法，再做一次数据库连接来查询总计录数，不免有点多此一举、浪费时间、浪费代码、浪费生命。言重了~在这种情况下，我们就可以利用二元组，在一次数据库连接中，得到总计录数、当前页记录，并存储到其中，简单明了！
四. 自定义泛型接口、泛型类和泛型方法
从上面的内容中，大家已经明白了泛型的具体运作过程。也知道了接口、类和方法也都可以使用泛型去定义，以及相应的使用。是的，在具体使用时，可以分为泛型接口、泛型类和泛型方法。
自定义泛型接口、泛型类和泛型方法与上述java源码中的list、arraylist类似。如下，我们看一个最简单的泛型类和方法定义：
public class generictest { public static void main(string[] args) { box<string> name = new box<string>("corn"); system.out.println("name:" + name.getdata()); } } class box<t> { private t data; public box() { } public box(t data) { this.data = data; } public t getdata() { return data; } }
在泛型接口、泛型类和泛型方法的定义过程中，我们常见的如t、e、k、v等形式的参数常用于表示泛型形参，由于接收来自外部使用时候传入的类型实参。那么对于不同传入的类型实参，生成的相应对象实例的类型是不是一样的呢？
public class generictest { public static void main(string[] args) { box<string> name = new box<string>("corn"); box<integer> age = new box<integer>(712); system.out.println("name class:" + name.getclass()); // com.qqyumidi.box system.out.println("age class:" + age.getclass()); // com.qqyumidi.box system.out.println(name.getclass() == age.getclass()); // true } }
由此，我们发现，在使用泛型类时，虽然传入了不同的泛型实参，但并没有真正意义上生成不同的类型，传入不同泛型实参的泛型类在内存上只有一个，即还是原来的最基本的类型（本实例中为box），当然，在逻辑上我们可以理解成多个不同的泛型类型。
究其原因，在于java中的泛型这一概念提出的目的，导致其只是作用于代码编译阶段，在编译过程中，对于正确检验泛型结果后，会将泛型的相关信息擦出，也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。
五. 类型通配符
接着上面的结论，我们知道，box<number>和box<integer>实际上都是box类型，现在需要继续探讨一个问题，那么在逻辑上，类似于box<number>和box<integer>是否可以看成具有父子关系的泛型类型呢？
为了弄清这个问题，我们继续看下下面这个例子:
public class generictest { public static void main(string[] args) { box<number> name = new box<number>(99); box<integer> age = new box<integer>(712); getdata(name); //the method getdata(box<number>) in the type generictest is //not applicable for the arguments (box<integer>) getdata(age); // 1 } public static void getdata(box<number> data){ system.out.println("data :" + data.getdata()); } }
我们发现，在代码//1处出现了错误提示信息：the method getdata(box<number>) in the t ype generictest is not applicable for the arguments (box<integer>)。显然，通过提示信息，我们知道box<number>在逻辑上不能视为box<integer>的父类。那么，原因何在呢？
public class generictest { public static void main(string[] args) { box<integer> a = new box<integer>(712); box<number> b = a; // 1 box<float> f = new box<float>(3.14f); b.setdata(f); // 2 } public static void getdata(box<number> data) { system.out.println("data :" + data.getdata()); } } class box<t> { private t data; public box() { } public box(t data) { setdata(data); } public t getdata() { return data; } public void setdata(t data) { this.data = data; } }
这个例子中，显然//1和//2处肯定会出现错误提示的。在此我们可以使用反证法来进行说明。
假设box<number>在逻辑上可以视为box<integer>的父类，那么//1和//2处将不会有错误提示了，那么问题就出来了，通过getdata()方法取出数据时到底是什么类型呢？integer? float? 还是number？且由于在编程过程中的顺序不可控性，导致在必要的时候必须要进行类型判断，且进行强制类型转换。显然，这与泛型的理念矛盾，因此，在逻辑上box<number>不能视为box<integer>的父类。
好，那我们回过头来继续看“类型通配符”中的第一个例子，我们知道其具体的错误提示的深层次原因了。那么如何解决呢？总部能再定义一个新的函数吧。这和java中的多态理念显然是违背的，因此，我们需要一个在逻辑上可以用来表示同时是box<integer>和box<number>的父类的一个引用类型，由此，类型通配符应运而生。
类型通配符一般是使用 ? 代替具体的类型实参。注意了，此处是类型实参，而不是类型形参！且box<?>在逻辑上是box<integer>、box<number>...等所有box<具体类型实参>的父类。由此，我们依然可以定义泛型方法，来完成此类需求。
public class generictest { public static void main(string[] args) { box<string> name = new box<string>("corn"); box<integer> age = new box<integer>(712); box<number> number = new box<number>(314); getdata(name); getdata(age); getdata(number); } public static void getdata(box<?> data) { system.out.println("data :" + data.getdata()); } }
有时候，我们还可能听到类型通配符上限和类型通配符下限。具体有是怎么样的呢？
在上面的例子中，如果需要定义一个功能类似于getdata()的方法，但对类型实参又有进一步的限制：只能是number类及其子类。此时，需要用到类型通配符上限。
public class generictest { public static void main(string[] args) { box<string> name = new box<string>("corn"); box<integer> age = new box<integer>(712); box<number> number = new box<number>(314); getdata(name); getdata(age); getdata(number); //getuppernumberdata(name); // 1 getuppernumberdata(age); // 2 getuppernumberdata(number); // 3 } public static void getdata(box<?> data) { system.out.println("data :" + data.getdata()); } public static void getuppernumberdata(box<? extends number> data){ system.out.println("data :" + data.getdata()); } }
此时，显然，在代码//1处调用将出现错误提示，而//2 //3处调用正常。
类型通配符上限通过形如box<? extends number>形式定义，相对应的，类型通配符下限为box<? super number>形式，其含义与类型通配符上限正好相反
六. 怎么构建复杂模型如list元组？
泛型的一个重要好处是能够简单而安全地创建复杂的模型。如list元组。
package generics; import java.util.arraylist; class threetuple2<a,b,c>{ public final a first; public final b second; private final c three; public threetuple2(a a,b b,c c){ first = a; second = b; three = c; } public string tostring(){ return "(" + first + "," + second + "," + three + ")"; } } public class tuplelist<a,b,c> extends arraylist<threetuple2<a,b,c>> { static threetuple2<integer,string,character> h(){ return new threetuple2<integer,string,character>(99,"掌上洪城",'a'); } public static void main(string[] args) { tuplelist<integer,string,character> ts = new tuplelist<integer,string,character>(); ts.add(h()); ts.add(h()); for(threetuple2<integer,string,character> ttp:ts) system.out.println(ttp); } } package generics; import java.util.arraylist; class threetuple2<a,b,c>{ public final a first; public final b second; private final c three; public threetuple2(a a,b b,c c){ first = a; second = b; three = c; } public string tostring(){ return "(" + first + "," + second + "," + three + ")"; } } public class tuplelist<a,b,c> extends arraylist<threetuple2<a,b,c>> { static threetuple2<integer,string,character> h(){ return new threetuple2<integer,string,character>(99,"掌上洪城",'a'); } public static void main(string[] args) { tuplelist<integer,string,character> ts = new tuplelist<integer,string,character>(); ts.add(h()); ts.add(h()); for(threetuple2<integer,string,character> ttp:ts) system.out.println(ttp); } } /* 输出结果为： (99,掌上洪城,a) (99,掌上洪城,a) */
七. 泛型的擦除
package generics; import java.util.*; 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); } } /* * output: true */// :~
在泛型内部，无法获得任何有关泛型参数类型的信息。
arraylist<string>和arraylist<integer>是相同的类型。
擦除的补偿
要想在表达式中使用类型，需要显式地传递类型的class对象。
package generics; class building { } class house extends building { } public class classtypecapture<t> { class<t> kind; public classtypecapture(class<t> kind) { this.kind = kind; } public boolean f(object arg) { return kind.isinstance(arg); } public static void main(string[] args) { classtypecapture<building> ctt1 = new classtypecapture<building>(building.class); system.out.println(ctt1.f(new building())); system.out.println(ctt1.f(new house())); classtypecapture<house> ctt2 = new classtypecapture<house>(house.class); system.out.println(ctt2.f(new building())); system.out.println(ctt2.f(new house())); } } /* * output: true true false true */// :~
八. 可以创建泛型数组吗？相应的应用场景怎么处理？
正如你在下面示例erased.java中所见，不能创建泛型数组。一般的解决方案是任何想要创建泛型数组的地方都使用arraylist:
package generics; public class erased<t> { private final int size = 100; public static void f(object arg) { if (arg instanceof t) { } // cannot make a static reference to the non-static type t t var = new t(); // error t[] array = new t[size]; // error t[] array = (t) new object[size]; // unchecked warning } } /// :~
使用arraylist示例
package generics; 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); } } /// :~
九. 泛型限定（上限和下限）的表达式是怎样的？
上限：？extends e：可以接收e类型或者e的子类型对象。
下限：？super e：可以接收e类型或者e的父类型对象。
上限什么时候用：往集合中添加元素时，既可以添加e类型对象，又可以添加e的子类型对象。为什么？因为取的时候，e类型既可以接收e类对象，又可以接收e的子类型对象。
下限什么时候用：当从集合中获取元素进行操作的时候，可以用当前元素的类型接收，也可以用当前元素的父类型接收。
十. 什么时候用泛型？
当接口、类及方法中的操作的引用数据类型不确定的时候，以前用的object来进行扩展的，现在可以用泛型来表示。这样可以避免强转的麻烦，而且将运行问题转移到的编译时期。
泛型的细节：
1）、泛型到底代表什么类型取决于调用者传入的类型，如果没传，默认是object类型；
2）、使用带泛型的类创建对象时，等式两边指定的泛型必须一致；
原因：编译器检查对象调用方法时只看变量，然而程序运行期间调用方法时就要考虑对象具体类型了；
3）、等式两边可以在任意一边使用泛型，在另一边不使用(考虑向后兼容)；
arraylistf7e83be87db5cd2d9a8a0b8117b38cd4al = new arraylista87fdacec66f0909fc0757c19f2d2b1d(); //错
//要保证左右两边的泛型具体类型一致就可以了，这样不容易出错。
arraylistd876df6b879603b519fa77c3a7ff60d2 al = new arraylistf7e83be87db5cd2d9a8a0b8117b38cd4();
al.add(aa); //错
//因为集合具体对象中既可存储string，也可以存储object的其他子类，所以添加具体的类型对象不合适，类型检查会出现安全问题。 ？extendsobject 代表object的子类型不确定，怎么能添加具体类型的对象呢？
public static voidmethod(arraylista559c2fd4cc43ceac6831fa3de4b0d38 al) {
al.add(abc); //错
//只能对al集合中的元素调用object类中的方法，具体子类型的方法都不能用，因为子类型不确定。
十一. java类库中的泛型有那些？
所有的标准集合接口都是泛型化的—— collectiond94943c0b4933ad8cac500132f64757f、listd94943c0b4933ad8cac500132f64757f、setd94943c0b4933ad8cac500132f64757f 和 mapb77a8d9c3c319e50d4b02a976b347910。类似地，集合接口的实现都是用相同类型参数泛型化的，所以hashmapb77a8d9c3c319e50d4b02a976b347910 实现 mapb77a8d9c3c319e50d4b02a976b347910 等。
除了集合类之外，java 类库中还有几个其他的类也充当值的容器。这些类包括 weakreference、softreference 和 threadlocal。