昨天写代码发现一个问题，就是使用泛型虽然给我们带来了很大的安全问题，但是用了泛型我们是不是只能放置着一种类型的对象了，如下
                     TreeMap<Worker, String>  map=new TreeMap<Worker, String>();
                map.put(new Worker("黄强", 24), "北京");
                map.put(new Worker("小小", 21), "上海");
这是我们如果要放入其他对象，我们怎么办了，很纠结？

张孝祥老师的java基础加强里面有讲到，这是我的代码笔记，希望对你有用……

1. package staticImport.cn.itcast.day2;
   
2. import java.lang.reflect.Method;
   
3. import java.lang.reflect.ParameterizedType;
   
4. import java.lang.reflect.Type;
   
5. import java.util.ArrayList;
   
6. import java.util.Collection;
   
7. import java.util.Date;
   
8. import java.util.HashMap;
   
9. import java.util.Map;
   
10. import java.util.Set;
    
11. import java.util.Vector;
    
12. 
    
13. public class GenericTest {
    
14. public static void main(String args[])throws Exception{
    
15. ArrayList<String> list1 = new ArrayList<String>();
    
16. list1.add("hello heima");
    
17. ArrayList<Integer> list2 = new ArrayList<Integer>();
    
18. //两个集合都是泛型参数实例化，但是返回的class字节码还是一样的
    
19. System.out.println(list1.getClass()==list2.getClass());
    
20. /**往list2中添加字符串:list2.add("abc");
    
21. 由于ArrayList的泛型参数是Integer，如果存放字符串类型，在编译的时候是会报错的
    
22. 所以要使用泛型来实现。因为编译生成的字节码会去掉泛型的信息，只要跳过编译器，就可以往某
    
23. 非泛型集合中添加其它类型的数据.*/
    
24. list2.getClass().getMethod("add", Object.class).invoke(list2, "abc");
    
25. System.out.println(list2.get(0));
    
26. 
    
27. /**通配符*/
    
28. printCollection(list1);
    
29. 
    
30. /**泛型----Map.key<key,value>*/
    
31. HashMap<String, Integer> map = new HashMap<String,Integer>();
    
32. map.put("zxx", 28);
    
33. map.put("bxd", 27);
    
34. map.put("yxf", 45);
    
35. Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
    
36. for(Map.Entry<String, Integer> entry:entrySet){
    
37. System.out.println(entry.getKey() + ":" + entry.getValue());
    
38. }
    
39. 
    
40. /**泛型的语法定义和类型的推断*/
    
41. // int x = add(3,3);//返回值为int类型
    
42. Object x1 = add(3.5,3);//T的取值是取得两个参数类型的交集
    
43. Object x2 = add(3.5,"abc");
    
44. 
    
45. /**交换数组中两个元素的位置*/
    
46. swap(new String[]{"abc","def","hij"},1,2);
    
47. //swap(new int[]{1,2,3,4,5},2,3);这条语句会报错，泛型的实际类型，只能是对象类型、引用类型，不能是基本类型
    
48. 
    
49. 
    
50. /**练习题*/
    
51. Object obj = "abc";
    
52. autoConvert(obj);
    
53. //2
    
54. // fillArray();
    
55. copy1(new Vector<String>(),new String[10]);
    
56. copy2(new Date[10],new String[10]);//类型推断为Object
    
57. // copy1(new Vector<Date>(),new String[10]);//此处报错：已经为Vector的泛型指定了date类型，说明T就是Date，
    
58. // 当类型参数被实例化之后，就具有传递性，T一定是Date
    
59. 
    
60. /**类上面加泛型*/
    
61. GenericDao<ReflectPoint> dao = new GenericDao<ReflectPoint>();
    
62. dao.add(new ReflectPoint(3,3));
    
63. ReflectPoint rp = dao.findById(1);
    
64. 
    
65. 
    
66. /** 通过反射获取泛型的实际类型参数*/
    
67. //Vector<Date> v1 = new Vector<Date>();这时通过V1对象是检查不出来Vector中泛型的类型的。只能通过方法
    
68. Method applyMethod = GenericTest.class.getMethod("applyVector", Vector.class);
    
69. Type type[] = applyMethod.getGenericParameterTypes();
    
70. ParameterizedType pType = (ParameterizedType)type[0];
    
71. System.out.println(pType.getRawType());
    
72. System.out.println(pType.getActualTypeArguments()[0]);
    
73. }
    
74. public static <T> void applyVector(Vector<Date> v1){
    
75. 
    
76. }
    
77. private static <T> T autoConvert(Object obj){
    
78. return (T)obj;
    
79. }
    
80. private static <T> void fillArray(T a[],T obj){
    
81. for(int i=0;i<a.length;i++){
    
82. a[i] = obj;
    
83. }
    
84. }
    
85. private static <T> void copy1(Collection<T> src,T a[]){
    
86. int len = src.size();
    
87. // for()
    
88. }
    
89. private static <T> void copy2(T src[],T dest[]){
    
90. 
    
91. }
    
92. private static <T>/*声明泛型类型，在后面就可以使用了*/ void swap(T[] array,int i,int j){
    
93. T temp ;
    
94. temp = array[i];
    
95. array[i] = array[j];
    
96. array[j] = temp;
    
97. }
    
98. 
    
99. private static <T> T add(T t1,T t2){
    
100. return null;
     
101. }
     
102. /*
     
103. 通配符可以作为一个引用型变量来引用一个类型，但是引用别人以后，你不能拿着它去调用一个与
     
104. 参数有关系的方法，就是与类型有关的方法你不能去调用 ，例如：add(E e);但是你可以调用
     
105. size()方法，它与通配符引用的类型没有关系
     
106. */
     
107. private static void printCollection(Collection<?> collection) {
     
108. for(Object obj:collection){
     
109. System.out.println(obj);
     
110. }
     
111. }
     
112. }
     
113. class ReflectPoint{
     
114. public ReflectPoint(int i, int j) {
     
115. this.x = i;
     
116. this.y = j;
     
117. }
     
118. private int x;
     
119. public int y;
     
120. }
     
121. 连涉及到的笔记一块送到：
     

复制代码

泛型的作用
泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，编译器编译带类型说明的集合时会去除掉“类型”信息，使程序运行效率不受影响，对于参数化的泛型类型，getClass( )方法的返回值和原始类型完全一样。由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，例如，用反射得到集合，再调用add方法即可。
系统，不让我从doc中赋值文字，郁闷！粘到上面是一堆代码……

你可以使用多重包装了， 先把Object 对象放进ArrayList里面， 再把ArrayList 放进Map 对象里面 或者把Map里面放Map ， 这样就解决了