java泛型详解

1、什么是java泛型？

泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

2、为什么需要泛型？

Java语言引入泛型的好处是安全简单。可以将运行时错误提前到编译时错误。

在java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

示例代码如下：

[java] view plain copy

1. package Generics;  
2.   
3. class SimpleGen {  
4.     private Object ob;  
5.   
6.     public SimpleGen(Object ob) {  
7.         this.ob = ob;  
8.     }  
9.   
10.     public Object getOb() {  
11.         return ob;  
12.     }  
13.   
14.     public void setOb(Object ob) {  
15.         this.ob = ob;  
16.     }  
17.   
18.     public void showType() {  
19.         System.out.println(ob.getClass().getName());  
20.     }  
21. }  
22.   
23. public class SimpleGenDemo1 {  
24.     public static void main(String[] args) {  
25.         SimpleGen sg = new SimpleGen(new Integer(99));  
26.         sg.showType();  
27.         int i = (Integer) sg.getOb(); //强制类型转换，系统可能会抛一个ClassCastException异常信息  
28.         System.out.println("value = " + i);  
29.         SimpleGen sg2 = new SimpleGen("掌上洪城");  
30.         sg2.showType();               //强制类型转换，系统可能会抛一个ClassCastException异常信息  
31.         String str = (String) sg2.getOb();  
32.         System.out.println("value = " + str);  
33.     }  
34. }  
35. /* 输出结果为： 
36. java.lang.Integer 
37. value = 99 
38. java.lang.String 
39. value = 掌上洪城 
40. */  

3、什么是元组类库，怎么用？

3.1、为什么使用元组tuple？

元组和列表list一样，都可能用于数据存储，包含多个数据；但是和列表不同的是：列表只能存储相同的数据类型，而元组不一样，它可以存储不同的数据类型，比如同时存储int、string、list等，并且可以根据需求无限扩展。

比如说在web应用中，经常会遇到一个问题就是数据分页问题，查询分页需要包含几点信息：当前页数、页大小；查询结果返回数据为：当前页的数据记录，但是如果需要在前台显示当前页、页大小、总页数等信息的时候，就必须有另外一个信息就是：数据记录总数，然后根据上面的信息进行计算得到总页数等信息。这个时候查询某一页信息的时候需要返回两个数据类型，一个是list（当前也的数据记录），一个是int（记录总数）。当然，完全可以在两个方法、两次数据库连接中得到这两个值。事实上在查询list的时候，已经通过sql查询得到总计录数，如果再开一个方法，再做一次数据库连接来查询总计录数，不免有点多此一举、浪费时间、浪费代码、浪费生命。言重了~在这种情况下，我们就可以利用二元组，在一次数据库连接中，得到总计录数、当前页记录，并存储到其中，简单明了！

3.2、代码实例

[java] view plain copy

1. package Generics;  
2.   
3. import java.util.Date;  
4.   
5. class TwoTuple<A,B>{  
6.     public final A first;  
7.     public final B second;  
8.   
9.     public TwoTuple(A a,B b){ //这里是括号，不是中括号  
10.         first = a;  
11.         second = b;  
12.     }  
13.     public String toString(){  
14.         return "(" + first + "," + second + ")";  
15.     }  
16. }  
17.   
18. class ThreeTuple<A,B,C> extends TwoTuple<A,B>{  
19.     private final C three;  
20.     public ThreeTuple(A a,B b,C c){  
21.         super(a,b);  
22.         three = c;  
23.     }  
24.     public String toString(){  
25.         return "(" + first + "," + second + "," + three + ")";  
26.     }  
27. }  
28. public class TupleTest {  
29.     public static void main(String[] args) {  
30.         TwoTuple<Integer,String> twoT = new TwoTuple<Integer,String>(99,"掌上洪城");  
31.         System.out.println(twoT);  
32.         System.out.println("======扩展元组类库后======");  
33.         ThreeTuple<Integer,String,Date> threeT= new ThreeTuple<Integer,String,Date>(99,"掌上洪城",new Date());  
34.         System.out.println(threeT);  
35.     }  
36. }  
37. /*输出结果为： 
38.  * (99,掌上洪城) 
39. ======扩展元组类库后====== 
40. (99,掌上洪城,Thu Apr 28 17:59:30 CST 2016) 
41.  * */  

4、怎么自定义泛型接口、泛型类？

4.1 java泛型接口、泛型类简介

泛型类中的类型参数几乎可以用于任何可以使用接口名、类名的地方，下面的代码示例展示了 JDK 5.0 中集合框架中的 Map 接口的定义的一部分：

public interface Map<K, V> {

public void put(K key, V value);

public V get(K key);

}

当声明或者实例化一个泛型的对象时，必须指定类型参数的值：

Map<String, String> map = newHashMap<String, String>();

对于常见的泛型模式，推荐的名称是：

 

K ——键，比如映射的键。

V ——值，比如 List 和 Set 的内容，或者 Map 中的值。

E ——异常类。

T ——泛型。

泛型不是协变的

 

关于泛型的混淆，一个常见的来源就是假设它们像数组一样是协变的。其实它们不是协变的。List<Object> 不是 List<String> 的父类型。

 

如果 A 扩展 B，那么 A 的数组也是 B 的数组，并且完全可以在需要 B[] 的地方使用 A[]：

 

Integer[] intArray = new Integer[10];

Number[] numberArray = intArray;

 

上面的代码是有效的，因为一个Integer 是 一个 Number，因而一个 Integer 数组是 一个 Number 数组。但是对于泛型来说则不然。下面的代码是无效的：

 

List<Integer> intList = newArrayList<Integer>();

List<Number> numberList = intList; //invalid

 

最初，大多数 Java 程序员觉得这缺少协变很烦人，或者甚至是“坏的（broken）”，但是之所以这样有一个很好的原因。如果可以将List<Integer> 赋给 List<Number>，下面的代码就会违背泛型应该提供的类型安全：

 

List<Integer> intList = newArrayList<Integer>();

List<Number> numberList = intList; //invalid

numberList.add(new Float(3.1415));

 

因为 intList 和 numberList 都是有别名的，如果允许的话，上面的代码就会让您将不是 Integers 的东西放进 intList 中。

4.2 代码实例

[java] view plain copy

1. package Generics;  
2.   
3. import java.util.Random;  
4.   
5. interface Generator<T> {  
6.     public T next();  
7. }  
8.   
9. class Coffee{  
10.     public String toString(){  
11.         return getClass().getSimpleName();  
12.     }  
13. }  
14.   
15. class Mocha extends Coffee{}  
16. class Cappuccino extends Coffee{}  
17. class Breve extends Coffee{}  
18. class Latte extends Coffee{}  
19.   
20. class CoffeeGenerator implements Generator<Coffee>{ //T为Coffee  
21.     private static Random rand = new Random(47);  
22.     private Class[] types = {Latte.class, Mocha.class, Cappuccino.class, Breve.class};  
23.     public Coffee next(){ //T为Coffee  
24.         try {  
25.             return (Coffee)  
26.                     types[rand.nextInt(types.length)].newInstance();  
27.         } catch (Exception e) {  
28.             throw new RuntimeException(e);  
29.         }   
30.     }  
31. }  
32.   
33. public class InterfaceGenTest {  
34.     public static void main(String[] args) {  
35.         CoffeeGenerator gen = new CoffeeGenerator();  
36.         for(int i=0; i<4; i++){  
37.             System.out.println(gen.next());  
38.         }  
39.     }  
40. }  
41. /*Cappuccino 
42. Mocha 
43. Cappuccino 
44. Latte*/  

5 怎么自定义泛型方法。

5.1 泛型方法

       泛型方法使得该方法能独立于类而产生变化。以下是一个基本的指导原则：无论何时，只要你能做到，你就应该尽量使用泛型方法。也就是说，如果使用泛型方法可以取代将整个类泛型化，那么就应该只使用泛型方法，因为它可以使事情更清楚明白。另外，对于一个static的方法而言，无法访问泛型类的类型参数。所以，如果static方法需要使用泛型能力，就必须使其成为泛型方法。

       要定义泛型方法，只需将泛型参数列表置于返回值之前，就像下面这样：

5.2 代码示例

[java] view plain copy

1. package Generics;  
2.   
3. public class GenericMethods {  
4. //当方法操作的引用数据类型不确定的时候，可以将泛型定义在方法上  
5.     public <T> void f(T x){  
6.         System.out.println(x.getClass().getName());  
7.     }  
8.     public static void main(String[] args) {  
9.         GenericMethods gm = new GenericMethods();  
10.         gm.f(99);  
11.         gm.f("掌上洪城");  
12.         gm.f(new Integer(99));  
13.         gm.f(18.88);  
14.         gm.f('a');  
15.         gm.f(gm);  
16.     }  
17. }  
18. /* 输出结果： 
19. java.lang.Integer 
20. java.lang.String 
21. java.lang.Integer 
22. java.lang.Double 
23. java.lang.Character 
24. Generics.GenericMethods 
25.  */  

5.3 可变参数与泛型方法

泛型方法与可变参数列表能很好地共存：

[java] view plain copy

1. package Generics;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5.   
6. public class GenericVarargs {  
7.     public static <T> List<T> makeList(T... args){  
8.         List<T> result = new ArrayList<T>();  
9.         for(T item:args)  
10.             result.add(item);  
11.         return result;         
12.     }  
13.     public static void main(String[] args) {  
14.         List ls = makeList("A");  
15.         System.out.println(ls);  
16.         ls = makeList("A","B","C");  
17.         System.out.println(ls);  
18.         ls = makeList("ABCDEFGHIJKLMNOPQRSTUVWXYZ".split(""));  
19.         System.out.println(ls);  
20.     }  
21. }  
22. /* 
23. [A] 
24. [A, B, C] 
25. [A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z] 
26. */  

静态方法上的泛型：静态方法无法访问类上定义的泛型。如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。

    public static<Q> void function(Q t) {

        System.out.println("function:"+t);

    }

6、怎么构建复杂模型如list元组？

泛型的一个重要好处是能够简单而安全地创建复杂的模型。如List元组。

[java] view plain copy

1. package Generics;  
2.   
3. import java.util.ArrayList;  
4.   
5. class ThreeTuple2<A,B,C>{  
6.     public final A first;  
7.     public final B second;  
8.     private final C three;  
9.     public ThreeTuple2(A a,B b,C c){  
10.         first = a;  
11.         second = b;  
12.         three = c;  
13.     }  
14.     public String toString(){  
15.         return "(" + first + "," + second + "," + three + ")";  
16.     }  
17. }  
18.   
19. public class TupleList<A,B,C> extends ArrayList<ThreeTuple2<A,B,C>> {  
20.     static ThreeTuple2<Integer,String,Character> h(){  
21.         return new ThreeTuple2<Integer,String,Character>(99,"掌上洪城",'a');  
22.     }  
23.     public static void main(String[] args) {  
24.         TupleList<Integer,String,Character> ts = new TupleList<Integer,String,Character>();  
25.         ts.add(h());  
26.         ts.add(h());  
27.         for(ThreeTuple2<Integer,String,Character> ttp:ts)  
28.         System.out.println(ttp);          
29.     }  
30. }  
31. package Generics;  
32.   
33. import java.util.ArrayList;  
34.   
35. class ThreeTuple2<A,B,C>{  
36.     public final A first;  
37.     public final B second;  
38.     private final C three;  
39.     public ThreeTuple2(A a,B b,C c){  
40.         first = a;  
41.         second = b;  
42.         three = c;  
43.     }  
44.     public String toString(){  
45.         return "(" + first + "," + second + "," + three + ")";  
46.     }  
47. }  
48.   
49. public class TupleList<A,B,C> extends ArrayList<ThreeTuple2<A,B,C>> {  
50.     static ThreeTuple2<Integer,String,Character> h(){  
51.         return new ThreeTuple2<Integer,String,Character>(99,"掌上洪城",'a');  
52.     }  
53.     public static void main(String[] args) {  
54.         TupleList<Integer,String,Character> ts = new TupleList<Integer,String,Character>();  
55.         ts.add(h());  
56.         ts.add(h());  
57.         for(ThreeTuple2<Integer,String,Character> ttp:ts)  
58.         System.out.println(ttp);          
59.     }  
60. }  
61. /* 输出结果为： 
62. (99,掌上洪城,a) 
63. (99,掌上洪城,a) 
64.  */  

7、泛型的擦除

7.1 代码实例：

[java] view plain copy

1. package generics;  
2.   
3. import java.util.*;  
4.   
5. public class ErasedTypeEquivalence {  
6.     public static void main(String[] args) {  
7.         Class c1 = new ArrayList<String>().getClass();  
8.         Class c2 = new ArrayList<Integer>().getClass();  
9.         System.out.println(c1 == c2);  
10.     }  
11. } /* 
12.      * Output: true 
13.      */// :~  

在泛型内部，无法获得任何有关泛型参数类型的信息。

ArrayList<String>和ArrayList<Integer>是相同的类型。

7.2 擦除的补偿

要想在表达式中使用类型，需要显式地传递类型的class对象。

[java] view plain copy

1. package generics;  
2. class Building {  
3. }  
4.   
5. class House extends Building {  
6. }  
7.   
8. public class ClassTypeCapture<T> {  
9.     Class<T> kind;  
10.   
11.     public ClassTypeCapture(Class<T> kind) {  
12.         this.kind = kind;  
13.     }  
14.   
15.     public boolean f(Object arg) {  
16.         return kind.isInstance(arg);  
17.     }  
18.   
19.     public static void main(String[] args) {  
20.         ClassTypeCapture<Building> ctt1 = new ClassTypeCapture<Building>(Building.class);  
21.         System.out.println(ctt1.f(new Building()));  
22.         System.out.println(ctt1.f(new House()));  
23.         ClassTypeCapture<House> ctt2 = new ClassTypeCapture<House>(House.class);  
24.         System.out.println(ctt2.f(new Building()));  
25.         System.out.println(ctt2.f(new House()));  
26.     }  
27. } /* 
28.      * Output: true true false true 
29.      */// :~  

8、可以创建泛型数组吗？相应的应用场景怎么处理？

正如你在下面示例Erased.java中所见，不能创建泛型数组。一般的解决方案是任何想要创建泛型数组的地方都使用ArrayList:

[java] view plain copy

1. package generics;  
2.   
3. public class Erased<T> {  
4.     private final int SIZE = 100;  
5.   
6.     public static void f(Object arg) {  
7.         if (arg instanceof T) {  
8.         } // Cannot make a static reference to the non-static type T  
9.         T var = new T(); // Error  
10.         T[] array = new T[SIZE]; // Error  
11.         T[] array = (T) new Object[SIZE]; // Unchecked warning  
12.     }  
13. } /// :~  

使用ArrayList示例

[java] view plain copy

1. package generics;  
2.   
3. import java.util.*;  
4.   
5. public class ListOfGenerics<T> {  
6.     private List<T> array = new ArrayList<T>();  
7.   
8.     public void add(T item) {  
9.         array.add(item);  
10.     }  
11.   
12.     public T get(int index) {  
13.         return array.get(index);  
14.     }  
15. } /// :~  

9、泛型通配符‘？’怎么用？

可以解决当具体类型不确定的时候，这个通配符就是 ?  ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。

 

例如Class<?>classType = Class.forName("java.lang.String");

 

下面我们先看看这些程序：

//Code list 2

void TestGen0Medthod1(List l) {

　for (Object o: l)

System.out.println(o);

}

看看这个方法有没有异议，这个方法会通过编译的，假如你传入String，就是这样List＜String＞。

接着我们调用它,问题就出现了，我们将一个List＜String＞当作List传给了方法，JVM会给我们一个警告，说这个破坏了类型安全，因为从List中返回的都是Object类型的，而让我们再看看下面的方法。

//Code list 3

void TestGen0Medthod1(List＜String＞ l) {

　for (Object o: l)

System.out.println(o);

}

因为这里的List＜String＞不是List＜Object＞的子类,不是String与Object的关系，就是说List＜String＞不隶属于list＜Object＞,他们不是继承关系，所以是不行的，这里的extends是表示限制的。

类型通配符是很神奇的，List＜?＞这个你能为他做什么呢?怎么都是“？”，它似乎不确定，他总不能返回一个？作为类型的数据吧，是啊他是不会返回一个“？”来问程序员的？JVM会做简单的思考的，看看代码吧，更直观些。

//code list 4

List＜String＞ l1 = newArrayList＜String＞();

li.add(“String”);

List＜?＞ l2 = l1;

System.out.println(l1.get(0));

这段代码没问题的，l1.get(0)将返回一个Object。

10、泛型限定（上限和下限）的表达式是怎样的？

上限：？extends E：可以接收E类型或者E的子类型对象。

下限：？super E：可以接收E类型或者E的父类型对象。

上限什么时候用：往集合中添加元素时，既可以添加E类型对象，又可以添加E的子类型对象。为什么？因为取的时候，E类型既可以接收E类对象，又可以接收E的子类型对象。

 

下限什么时候用：当从集合中获取元素进行操作的时候，可以用当前元素的类型接收，也可以用当前元素的父类型接收。

11、可以将基本类型作为泛型参数吗？

泛型的类型参数只能是类类型（包括自定义类），不能是简单类型（基本数据类型）。

12、什么时候用泛型？

当接口、类及方法中的操作的引用数据类型不确定的时候，以前用的Object来进行扩展的，现在可以用泛型来表示。这样可以避免强转的麻烦，而且将运行问题转移到的编译时期。

泛型的细节：

1）、泛型到底代表什么类型取决于调用者传入的类型，如果没传，默认是Object类型；

2）、使用带泛型的类创建对象时，等式两边指定的泛型必须一致；

    原因：编译器检查对象调用方法时只看变量，然而程序运行期间调用方法时就要考虑对象具体类型了；

3）、等式两边可以在任意一边使用泛型，在另一边不使用(考虑向后兼容)；

ArrayList<String>al = new ArrayList<Object>();  //错

//要保证左右两边的泛型具体类型一致就可以了，这样不容易出错。

ArrayList<?extends Object> al = new ArrayList<String>();

al.add("aa");  //错

//因为集合具体对象中既可存储String，也可以存储Object的其他子类，所以添加具体的类型对象不合适，类型检查会出现安全问题。 ？extendsObject 代表Object的子类型不确定，怎么能添加具体类型的对象呢？

public static voidmethod(ArrayList<? extends Object> al) {

al.add("abc");  //错

  //只能对al集合中的元素调用Object类中的方法，具体子类型的方法都不能用，因为子类型不确定。

13、Java类库中的泛型有那些？

所有的标准集合接口都是泛型化的—— Collection<V>、List<V>、Set<V> 和 Map<K,V>。类似地，集合接口的实现都是用相同类型参数泛型化的，所以HashMap<K,V> 实现 Map<K,V> 等。

除了集合类之外，Java 类库中还有几个其他的类也充当值的容器。这些类包括 WeakReference、SoftReference 和 ThreadLocal。

14、练习

做完这两个练习：

练习一：写一个使用泛型跟不使用泛型参数任意化的例子。代码略

练习二：修改ClassTypeCapture.java，添加一个Map<String,Class<?>>，一个addType(String typeName,Class<?>kind)方法和一个createNew()方法。createNew()将产生一个与其参数字符串关联的新实例，或者产生一条错误信息。

[java] view plain copy

1. package Generics;  
2.   
3. import java.util.*;  
4. import static org.greggordon.tools.Print.*;  
5.   
6. class Building {}  
7. class House extends Building {}  
8.   
9. public class ClassTypeCapture21<T> {  
10.     Class<?> kind;  
11.     Map<String, Class<?>> map;  
12.   
13.     public ClassTypeCapture21(Class<?> kind) {  
14.         this.kind = kind;  
15.     }  
16.   
17.     public ClassTypeCapture21(Class<?> kind, Map<String, Class<?>> map) {  
18.         this.kind = kind;  
19.         this.map = map;  
20.     }  
21.   
22.     public boolean f(Object arg) {  
23.         return kind.isInstance(arg);  
24.     }  
25.   
26.     public void addType(String typename, Class<?> kind) {  
27.         map.put(typename, kind);  
28.     }  
29.   
30.     public Object createNew(String typename) throws IllegalAccessException, InstantiationException {  
31.         if (map.containsKey(typename))  
32.             return map.get(typename).newInstance();  
33.         System.out.println(typename + " class not available");  
34.         return null;  
35.     }  
36.   
37.     public static void main(String[] args) {  
38.         ClassTypeCapture21<Building> ctt1 = new ClassTypeCapture21<Building>(Building.class);  
39.         println(ctt1.f(new Building()));  
40.         println(ctt1.f(new House()));  
41.         ClassTypeCapture21<House> ctt2 = new ClassTypeCapture21<House>(House.class);  
42.         println(ctt2.f(new Building()));  
43.         println(ctt2.f(new House()));  
44.         ClassTypeCapture21<Building> ct = new ClassTypeCapture21<Building>(Building.class,  
45.                 new HashMap<String, Class<?>>());  
46.         ct.addType("House", House.class);  
47.         ct.addType("Building", Building.class);  
48.         println("ct.map = " + ct.map);  
49.         try {  
50.             Building b = (Building) ct.createNew("Building");  
51.             House h = (House) ct.createNew("House");  
52.             print("b.getClass().getName(): ");  
53.             println(b.getClass().getName());  
54.             print("h.getClass().getName(): ");  
55.             println(h.getClass().getName());  
56.             print("House h is instance House: ");  
57.             println(h instanceof House);  
58.             print("House h is instance of Building: ");  
59.             println(h instanceof Building);  
60.             print("Building b is instance of House: ");  
61.             println(b instanceof House);  
62.             ct.createNew("String"); // String class not available  
63.         } catch (IllegalAccessException e) {  
64.             println("IllegalAccessException in main");  
65.         } catch (InstantiationException e) {  
66.             println("InstantiationException in main");  
67.         }  
68.     }  
69. }  
70. /* 
71. true 
72. true 
73. false 
74. true 
75. ct.map = {Building=class Generics.Building, House=class Generics.House} 
76. b.getClass().getName(): Generics.Building 
77. h.getClass().getName(): Generics.House 
78. House h is instance House: true 
79. House h is instance of Building: true 
80. Building b is instance of House: false 
81. String class not available 
82.  */