一.java泛型的引入和作用
在JDK1.5以后，引入了泛型的概念，泛型的出现可以有效的解决程序安全机制问题，将程序运行时的问题转到编译时期，使程序员在编译时期就能将可能出现的问题解决，这样提高了程序代码的健壮性，同时引入泛型以后，可以避免令程序员头痛的强制类型转换问题，是程序编译起来更简洁，下面我们先看看在泛型出现以前，程序员可能碰到的问题，如下代码所示：

1. package cn.itcast.generic;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. 
   
6. public class GenericTest {
   
7. 
   
8.         /**
   
9.          * @param args
   
10.          */
    
11.         public static void main(String[] args) {
    
12.                 //在泛型出现以前，一个集合类可以同时存有多种类型的数据，在取数据时不仅需要强制类型
    
13.                 //转换，还会出现安全机制
    
14.                 List list = new ArrayList();
    
15.         list.add(1);
    
16.         list.add("abc");
    
17.         list.add(1>2);
    
18.         //因为list集合类可以装各种类型数据，返回的是Object，因此需要类型的强制转换
    
19.         int value = (Integer) list.get(0);
    
20.         System.out.println(value);
    
21.    
    
22.       ArrayList<String>();
    
23.         list1.add("123");
    
24.      
    
25.      
    
26.         }
    
27. 
    
28. }
    

复制代码

对上述代码进行分析，由于ArrayList可以存储各种数据类型，如Integer，String，StringBuffer等，因此，程序员可以往里面存储各种数据，编译器在编译时不会报错，可是当需求上只能往里面加入一种类型（如String类型）的数据，而程序员却往里面存储了一个非String类型的数据，可是程序员在编译时编译器并没有报错，当交给用户运行时，却出现了错误，将给程序的修改带来，而加入泛型以后，编译器会自动扫描语法，当出现不是需要的类型时，编译器就会自动提醒程序员，因此，泛型的引入极大的提高了代码的安全性，同时，使用了泛型还能让程序员不必进行强制类型转换，减少了程序员的工作量，下面用泛型来改写上述代码：

1. package cn.itcast.generic;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. 
   
6. public class GenericTest {
   
7. 
   
8.         /**
   
9.          * @param args
   
10.          */
    
11.         public static void main(String[] args) {
    
12.         //泛型出现以后，在定义一个集合的时候，就为其指定了存储类型，当你往集合类存储的数据
    
13.         //不是指定的类型时，编译器会报错，这样就把运行时的问题转到编译时期，提高程序的安全性
    
14.         List<String> list1 = new ArrayList<String>();
    
15.         list1.add("123");
    
16.         list1.add("abc");
    
17.         //由于在集合中已经指定了存储类型，因此这里不需要强制类型转换
    
18.         String str = list1.get(1);
    
19.         System.out.println(str);
    
20.         }
    
21. }

复制代码

二.泛型内部的运行原理和深层次的应用
先看一组代码：

1. package cn.itcast.generic;
   
2. 
   
3. import java.lang.reflect.InvocationTargetException;
   
4. import java.util.ArrayList;
   
5. import java.util.List;
   
6. 
   
7. public class Theory {
   
8. 
   
9.         /**
   
10.          * @param args
    
11.          *  
    
12.          */
    
13.         public static void main(String[] args) throws Exception {
    
14.                 //建立一个存储字符串类型的集合
    
15.                 List<String> list1 = new ArrayList<String>();
    
16.         
    
17.         //建立一个存储Integer类型的集合
    
18.         List<Integer> list2 = new ArrayList<Integer>();
    
19.         
    
20.         //比较list1和list2的字节码是否相同
    
21.         System.out.println(list1.getClass()==list2.getClass());
    
22. }
    
23. }

复制代码

编译，运行文件，我们可以在控制台上看到打印一个true，从而验证了尽管在定义时，两个集合中所存储的类型不一致，但是当编译完成后生成的Class类的对象却是一致的，其实他内部的工作原理是，编译器在编译时会检查他的存储类型，从而检查语法有没有问题，而当编译通过后，他会自动去除参数类型，因此他们生成的Class对象才会一致，并且和原型一致，由此，我们便可以用反射的方式来操作一个集合，使得该集合能存储和本集合参数类型不一致的数据，如下面代码所示：

1. package cn.itcast.generic;
   
2. 
   
3. import java.lang.reflect.InvocationTargetException;
   
4. import java.util.ArrayList;
   
5. import java.util.List;
   
6. 
   
7. public class Theory {
   
8. 
   
9.         /**
   
10.          * @param args
    
11.          *  
    
12.          */
    
13.         public static void main(String[] args) throws Exception {
    
14. List<Integer> list2 = new ArrayList<Integer>();
    
15. //通过反射可以用list2来存储字符串类型的数据
    
16.         
    
17.         list2.getClass().getMethod("add", Object.class).invoke(list2, "abc");
    
18.         
    
19.         //打印集合中的数据
    
20.         System.out.println(list2.get(0));
    
21.         
    
22. 
    
23.         }
    
24. 
    
25. }

复制代码

三.java泛型通配符和泛型限定
泛型通配符用“？”表示，它代表着该类或方法可以接收任意类型的变量，下面来举个例子来说明通配符的概念，如下所示：

1. package cn.itcast.generic;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. 
   
6. public class Generic {
   
7. 
   
8.         /**
   
9.          * ?通配符可以引用其他各种类型化的参数，？通配符定义的变量主要用作引用，可以调用与参数
   
10.          * 无关的方法，不能调用与参数有关的方法
    
11.          * @param args
    
12.          */
    
13.         public static void main(String[] args) {
    
14.                 //建立一个存储String类型的集合
    
15.                 List<String> list1 = new ArrayList<String>();
    
16.                 //添加两个元素
    
17.                 list1.add("abc");
    
18.                 list1.add("xyz");
    
19.                 //建立一个存储Integer类型的集合
    
20.                 List<Integer> list2 = new ArrayList<Integer>();
    
21.                 //添加两个元素
    
22.                 list2.add(12);
    
23.                 list2.add(13);
    
24.                
    
25.                 //打印list集合类的元素
    
26.                 printLisst(list1);
    
27.                 //打印list集合类的元素
    
28.                 printLisst(list2);
    
29.         }
    
30. 
    
31.         private static void printLisst(List<?> list) {
    
32.                 System.out.println(list.size());
    
33.                 for(Object obj :list){
    
34.                         System.out.println(obj);
    
35.                 }
    
36.                
    
37.         }
    
38. 
    
39. }
    

复制代码

如上代码所示，我们定义了两个ArrayList集合，分别用来存储String类型的数据和Integer类型的数据，并且分别往这两个集合内存入两个元素，而后有定义了一个方法，该方法接收一个List集合，而参数类型为<?>，显然该类集合可以引用各种类型的参数，而该方法用来打印集合的长度，和迭代集合的元素，这个例子很好的说明了通配符的作用。下面是对通配符的一个总结：
通配符可以引用其他各种类型化的参数，？通配符定义的变量主要用作引用，可以调用与参数 无关的方法，不能调用与参数有关的方法 。
四.泛型的一个应用案例

学完泛型后，用泛型来做一个小案例，即泛型和HashMap的结合，如何去HashMap的键值对代码如下：

1. package cn.itcast.generic;
   
2. 
   
3. import java.util.HashMap;
   
4. import java.util.Map;
   
5. import java.util.Set;
   
6. import java.util.Map.Entry;
   
7. 
   
8. public class GernericApplication {
   
9. 
   
10.         /**
    
11.          * 利用泛型来取出操作HashMap集合
    
12.          * @param args
    
13.          */
    
14.         public static void main(String[] args) {
    
15.                 //定义一个HashMap
    
16.                 HashMap<String,Integer> maps = new HashMap<String,Integer>();
    
17.                 //添加三条数据
    
18.                 maps.put("prt", 23);
    
19.                 maps.put("wb",20);
    
20.                 maps.put("wjj", 25);
    
21.                 //调用entrySet方法获得集合映射关系
    
22.                 Set<Map.Entry<String, Integer>> entrySet = maps.entrySet();
    
23.                 //迭代去数据
    
24.                 for(Entry<String,Integer> entry:entrySet){
    
25.                         String key =  entry.getKey();
    
26.                         int value = entry.getValue();
    
27.                         System.out.println(key+"="+value);
    
28.                 }
    
29.         }
    
30. 
    
31. }
    

复制代码

一.java泛型的引入和作用
在JDK1.5以后，引入了泛型的概念，泛型的出现可以有效的解决程序安全机制问题，将程序运行时的问题转到编译时期，使程序员在编译时期就能将可能出现的问题解决，这样提高了程序代码的健壮性，同时引入泛型以后，可以避免令程序员头痛的强制类型转换问题，是程序编译起来更简洁，下面我们先看看在泛型出现以前，程序员可能碰到的问题，如下代码所示：

1. package cn.itcast.generic;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. 
   
6. public class GenericTest {
   
7. 
   
8.         /**
   
9.          * @param args
   
10.          */
    
11.         public static void main(String[] args) {
    
12.                 //在泛型出现以前，一个集合类可以同时存有多种类型的数据，在取数据时不仅需要强制类型
    
13.                 //转换，还会出现安全机制
    
14.                 List list = new ArrayList();
    
15.         list.add(1);
    
16.         list.add("abc");
    
17.         list.add(1>2);
    
18.         //因为list集合类可以装各种类型数据，返回的是Object，因此需要类型的强制转换
    
19.         int value = (Integer) list.get(0);
    
20.         System.out.println(value);
    
21.    
    
22.       ArrayList<String>();
    
23.         list1.add("123");
    
24.      
    
25.      
    
26.         }
    
27. 
    
28. }
    

复制代码

对上述代码进行分析，由于ArrayList可以存储各种数据类型，如Integer，String，StringBuffer等，因此，程序员可以往里面存储各种数据，编译器在编译时不会报错，可是当需求上只能往里面加入一种类型（如String类型）的数据，而程序员却往里面存储了一个非String类型的数据，可是程序员在编译时编译器并没有报错，当交给用户运行时，却出现了错误，将给程序的修改带来，而加入泛型以后，编译器会自动扫描语法，当出现不是需要的类型时，编译器就会自动提醒程序员，因此，泛型的引入极大的提高了代码的安全性，同时，使用了泛型还能让程序员不必进行强制类型转换，减少了程序员的工作量，下面用泛型来改写上述代码：

1. package cn.itcast.generic;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. 
   
6. public class GenericTest {
   
7. 
   
8.         /**
   
9.          * @param args
   
10.          */
    
11.         public static void main(String[] args) {
    
12.         //泛型出现以后，在定义一个集合的时候，就为其指定了存储类型，当你往集合类存储的数据
    
13.         //不是指定的类型时，编译器会报错，这样就把运行时的问题转到编译时期，提高程序的安全性
    
14.         List<String> list1 = new ArrayList<String>();
    
15.         list1.add("123");
    
16.         list1.add("abc");
    
17.         //由于在集合中已经指定了存储类型，因此这里不需要强制类型转换
    
18.         String str = list1.get(1);
    
19.         System.out.println(str);
    
20.         }
    
21. }

复制代码

二.泛型内部的运行原理和深层次的应用
先看一组代码：

1. package cn.itcast.generic;
   
2. 
   
3. import java.lang.reflect.InvocationTargetException;
   
4. import java.util.ArrayList;
   
5. import java.util.List;
   
6. 
   
7. public class Theory {
   
8. 
   
9.         /**
   
10.          * @param args
    
11.          *  
    
12.          */
    
13.         public static void main(String[] args) throws Exception {
    
14.                 //建立一个存储字符串类型的集合
    
15.                 List<String> list1 = new ArrayList<String>();
    
16.         
    
17.         //建立一个存储Integer类型的集合
    
18.         List<Integer> list2 = new ArrayList<Integer>();
    
19.         
    
20.         //比较list1和list2的字节码是否相同
    
21.         System.out.println(list1.getClass()==list2.getClass());
    
22. }
    
23. }

复制代码

编译，运行文件，我们可以在控制台上看到打印一个true，从而验证了尽管在定义时，两个集合中所存储的类型不一致，但是当编译完成后生成的Class类的对象却是一致的，其实他内部的工作原理是，编译器在编译时会检查他的存储类型，从而检查语法有没有问题，而当编译通过后，他会自动去除参数类型，因此他们生成的Class对象才会一致，并且和原型一致，由此，我们便可以用反射的方式来操作一个集合，使得该集合能存储和本集合参数类型不一致的数据，如下面代码所示：

1. package cn.itcast.generic;
   
2. 
   
3. import java.lang.reflect.InvocationTargetException;
   
4. import java.util.ArrayList;
   
5. import java.util.List;
   
6. 
   
7. public class Theory {
   
8. 
   
9.         /**
   
10.          * @param args
    
11.          *  
    
12.          */
    
13.         public static void main(String[] args) throws Exception {
    
14. List<Integer> list2 = new ArrayList<Integer>();
    
15. //通过反射可以用list2来存储字符串类型的数据
    
16.         
    
17.         list2.getClass().getMethod("add", Object.class).invoke(list2, "abc");
    
18.         
    
19.         //打印集合中的数据
    
20.         System.out.println(list2.get(0));
    
21.         
    
22. 
    
23.         }
    
24. 
    
25. }

复制代码

三.java泛型通配符和泛型限定
泛型通配符用“？”表示，它代表着该类或方法可以接收任意类型的变量，下面来举个例子来说明通配符的概念，如下所示：

1. package cn.itcast.generic;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. 
   
6. public class Generic {
   
7. 
   
8.         /**
   
9.          * ?通配符可以引用其他各种类型化的参数，？通配符定义的变量主要用作引用，可以调用与参数
   
10.          * 无关的方法，不能调用与参数有关的方法
    
11.          * @param args
    
12.          */
    
13.         public static void main(String[] args) {
    
14.                 //建立一个存储String类型的集合
    
15.                 List<String> list1 = new ArrayList<String>();
    
16.                 //添加两个元素
    
17.                 list1.add("abc");
    
18.                 list1.add("xyz");
    
19.                 //建立一个存储Integer类型的集合
    
20.                 List<Integer> list2 = new ArrayList<Integer>();
    
21.                 //添加两个元素
    
22.                 list2.add(12);
    
23.                 list2.add(13);
    
24.                
    
25.                 //打印list集合类的元素
    
26.                 printLisst(list1);
    
27.                 //打印list集合类的元素
    
28.                 printLisst(list2);
    
29.         }
    
30. 
    
31.         private static void printLisst(List<?> list) {
    
32.                 System.out.println(list.size());
    
33.                 for(Object obj :list){
    
34.                         System.out.println(obj);
    
35.                 }
    
36.                
    
37.         }
    
38. 
    
39. }
    

复制代码

如上代码所示，我们定义了两个ArrayList集合，分别用来存储String类型的数据和Integer类型的数据，并且分别往这两个集合内存入两个元素，而后有定义了一个方法，该方法接收一个List集合，而参数类型为<?>，显然该类集合可以引用各种类型的参数，而该方法用来打印集合的长度，和迭代集合的元素，这个例子很好的说明了通配符的作用。下面是对通配符的一个总结：
通配符可以引用其他各种类型化的参数，？通配符定义的变量主要用作引用，可以调用与参数 无关的方法，不能调用与参数有关的方法 。
四.泛型的一个应用案例

学完泛型后，用泛型来做一个小案例，即泛型和HashMap的结合，如何去HashMap的键值对代码如下：

1. package cn.itcast.generic;
   
2. 
   
3. import java.util.HashMap;
   
4. import java.util.Map;
   
5. import java.util.Set;
   
6. import java.util.Map.Entry;
   
7. 
   
8. public class GernericApplication {
   
9. 
   
10.         /**
    
11.          * 利用泛型来取出操作HashMap集合
    
12.          * @param args
    
13.          */
    
14.         public static void main(String[] args) {
    
15.                 //定义一个HashMap
    
16.                 HashMap<String,Integer> maps = new HashMap<String,Integer>();
    
17.                 //添加三条数据
    
18.                 maps.put("prt", 23);
    
19.                 maps.put("wb",20);
    
20.                 maps.put("wjj", 25);
    
21.                 //调用entrySet方法获得集合映射关系
    
22.                 Set<Map.Entry<String, Integer>> entrySet = maps.entrySet();
    
23.                 //迭代去数据
    
24.                 for(Entry<String,Integer> entry:entrySet){
    
25.                         String key =  entry.getKey();
    
26.                         int value = entry.getValue();
    
27.                         System.out.println(key+"="+value);
    
28.                 }
    
29.         }
    
30. 
    
31. }
    

复制代码