javaweb学习总结六(泛型)

一：泛型的概念

泛型用来现在集合中的存储类型，防止取出时强制转换发生错误。

1：没有使用泛型时，如下：

1 @Test
2     public void test1() {
3         List list = new ArrayList();
4         list.add("aaa");
5         Integer i = (Integer) list.get(0); // 编译时并不会报错
6         System.out.println(i);
7     }

而是运行时错误

2：使用泛型后，如下：

二：使用泛型进行存取

可以使用传统的迭代器的keyset或者entryset方式，或者使用增强for循环

 1 @Test
 2     public void test3() {
 3         Map<Integer, String> map = new HashMap<Integer, String>();
 4         map.put(1, "aaa");
 5         map.put(2, "bbb");
 6         map.put(3, "ccc");
 7
 8         // 传统keyset
 9         System.out.println("传统keyset方式......");
10         Set<Integer> set = map.keySet();
11         Iterator<Integer> it = set.iterator();
12         while (it.hasNext()) {
13             Integer key = it.next();
14             String value = map.get(key);
15             System.out.println(key + "=" + value);
16         }
17         // keyset 增强for
18         System.out.println("keyset...增强for");
19         for (Integer key : map.keySet()) {
20             String value = map.get(key);
21             System.out.println(key + "=" + value);
22         }
23         // 传统entryset
24         System.out.println("传统entryset方式");
25         Set<Map.Entry<Integer, String>> entry = map.entrySet();
26         Iterator<Entry<Integer, String>> item = entry.iterator();
27         while (item.hasNext()) {
28             Entry<Integer, String> en = item.next();
29             Integer key = en.getKey();
30             String value = en.getValue();
31             System.out.println(key + "=" + value);
32         }
33         // entryset 增强for
34         System.out.println("entryset...增强for");
35         for (Map.Entry<Integer, String> entr : map.entrySet()) {
36             Integer key = entr.getKey();
37             String value = entr.getValue();
38             System.out.println(key + "=" + value);
39         }
40     }

这里要注意，hashmap存储是安装hashcode进行排序的，如果想按照存入时的

顺序取出，推荐使用LinkedHashMap类，因为它的数据结构是链表。

三：泛型使用注意事项

1：使用泛型时，定义变量和创建对象（左右两边）泛型参数类型要一致

ArrayList<Object> list = new ArrayList<String>();

ArrayList<String> list = new ArrayList<Object>();

以上两种方式都是错误的！

a:  ArrayList  list = new ArrayList<String>();

b:  ArrayList<String> list = new ArrayList();

以上两种方式都是正确的！

a方式是为了兼容jdk1.5之前的程序，如果在jdk1.5之后写程序，会使用到泛型，想要调用

jdk1.5之前的程序，必须兼容此种情况。

b方式是为了兼容不同编程习惯的程序员之间可以互相调用。

2：擦除

在编译期时，使用泛型可以避免类型转换的错误，但是为了使泛型不影响程序运行效率，在生成

class文件时，泛型信息会被忽略掉。

四：自定义泛型

1：自定义泛型方法

如下在方法上声明泛型：

如果有返回值，可以避免类型的强制转换：

可以声明多个泛型：

1 public <T, K, V> void defineGeneric(T t, K k, V v) {
2         System.out.println(t + ":" + k + ":" + v);
3     }

练习题：使用泛型，颠倒数组内的元素

 1     @Test
 2     public void test5() {
 3         Integer[] arr = { 1, 2, 3, 4, 5, 6 };
 4         System.out.println(Arrays.toString(arr));
 5         reverse(arr);
 6         System.out.println(Arrays.toString(arr));
 7
 8     }
 9
10     // 使用泛型，颠倒数组中所有的元素
11     public <T> void reverse(T[] t) {
12         for (int i = 0, j = t.length - 1; i < t.length / 2; i++, j--) {
13             exChange(t, i, j);
14         }
15     }
16
17     // 使用泛型，交互数组中两个元素
18     public <T> void exChange(T[] t, int a, int b) {
19         T temp = t[a];
20         t[a] = t[b];
21         t[b] = temp;
22     }

2：自定义泛型类

如果在类里有很多方法使用泛型，可以将泛型定义在类上。