黑马程序员_泛型、Collections类

-----------android培训、java培训、期待与您交流！ ------------

1.泛型概述
泛型是JDK5以后出现的新特性，主要是用于解决安全问题，是一个类型安全机制
泛型的好处：
a.泛型的出现将运行时期出现的问题类转换异常(ClassCastException)转移到了编译时期
b.避免了强制转换的麻烦


2.泛型的使用
使用格式:通过<>来定义要操作的引用数据类型
什么时候使用泛型
在API中，只要见到<>就要定义泛型，<>用于接受类型
当使用集合时，将集合中药存储的数据类型作为参数传递到<>中即可
泛型使用实例:

[java]  view plain copy

1. package cn.itcast;  
2.   
3. import java.util.Comparator;  
4. import java.util.Iterator;  
5. import java.util.TreeSet;  
6.   
7. class Test {  
8.     public static void main(String[] args) {  
9.         TreeSet<String> al = new TreeSet<String>(new MyComp());  
10.         al.add("fsd");  
11.         al.add("sf");  
12.         al.add("hgfhd");  
13.         al.add("jy");  
14.         al.add("j");  
15.         al.add("java03ye");  
16.   
17.         Iterator<String> it = al.iterator();  
18.         while (it.hasNext()) {  
19.             System.out.println(it.next());  
20.         }  
21.     }  
22. }  
23.   
24. class MyComp implements Comparator<String> {  
25.     public int compare(String s1, String s2) {  
26.         int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));  
27.         if (num == 0) {  
28.             return s1.compareTo(s2);  
29.         }  
30.         return num;  
31.     }  
32. }  

3.泛型类
在类声明时通过一个标示符标示类中某个字段的类型或者某个方法的返回值或参数的类型
什么时候定义泛型类
当类中要操作的引用数据类型不确定的时候就定义泛型来完成扩展
如何声明一个带泛型的类:
class 类名<泛型类型1，泛型类型2......> {
泛型类型 变量名;
泛型类型 方法名() {}
返回值类型 方法名(泛型类型 变量名){}
}
如何使用带泛型的类:
类名<具体类> 对象名 = new 类名<具体类>();
具体实例:

[java]  view plain copy

1. package cn.itcast;  
2.   
3. class Test {  
4.     public static void main(String[] args) {  
5.         Utils<Person> u = new Utils<Person>();  
6.         u.setObject(new Person());  
7.         Person p = u.getObject();  
8.         System.out.println(p);  
9.     }  
10. }  
11.   
12. //泛型类  
13. class Utils<QQ> {  
14.     private QQ q;  
15.     public void setObject(QQ q) {  
16.         this.q = q;  
17.     }  
18.     public QQ getObject() {  
19.         return q;  
20.     }  
21. }  
22.   
23. class Person {  
24.       
25. }  

4.泛型方法
为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在泛型上
格式:
修饰符 <T> 返回值类型 方法名(形式参数) {
}


使用实例：

[java]  view plain copy

1. package cn.itcast;  
2.   
3. class Test {  
4.     public static void main(String[] args) {  
5.         Demo d = new Demo();  
6.         d.show(new Integer(3));  
7.         d.show(new Integer(4));  
8.         d.print("fds");  
9.   
10.     }  
11. }  
12.   
13. class Demo {  
14.     public <T> void show(T t) {  
15.         System.out.println("show:" + t);  
16.     }  
17.   
18.     public <Q> void print(Q q) {  
19.         System.out.println("print:" + q);  
20.     }  
21. }  

特殊点:
静态方法不可以访问类上定义的泛型
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上
例:

[java]  view plain copy

1. class Demo<T> {  
2.     public static <W> void show(W w) { //注意要放在返回值类型的前面  
3.           
4.     }  
5. }  

5.泛型接口
实例:

[java]  view plain copy

1. interface Inter<T> {  
2.     void show(T t);  
3. }  
4.   
5. class InterImpl implements Inter<String> {  
6.     public void show(String s) {  
7.         System.out.println(s);  
8.     }  
9. }  
10.   
11. class InterImpl1<Q> implements Inter<Q> {   //要操作的类型不确定时  
12.     public void show(Q q) {  
13.         System.out.println(q);  
14.     }  
15. }  

6.泛型的限定
设置泛型对象的上限使用extends,表示参数类型只能是该类型或该类型的子类：
声明对象：类名<? extends 类> 对象名
定义类：类名<泛型标签 extends 类>{}
设置泛型对象的下限使用super,表示参数类型只能是该类型或该类型的父类：
声明对象：类名<? super 类> 对象名称
定义类：类名<泛型标签 extends类>{}


泛型上限实例:

[java]  view plain copy

1. public static void main(String[] args) {  
2.         Person<Integer> p1 = new Person<>();  
3.         p1.setVal(99);  
4.         Person<Double> p2 = new Person<>();  
5.         p2.setVal(3.14);  
6.         Person<String> p3 = new Person<>();  
7.         p3.setVal("007");   
8.         show(p1);//√  
9.         show(p2);//√  
10.         show(p3);//×因为String不是Number的字类  
11. }  
12. public static void show(Person<? extends Number> p){//此处限定了Person的参数类型只能是Number或者是其子类  
13.         System.out.println(p.getVal());  
14. }  

泛型下限实例:

[java]  view plain copy

1. public static void main(String[] args) {  
2.         Person<Integer> p1 = new Person<>();  
3.         p1.setVal(99);//Integer  
4.         Person<Double> p2 = new Person<>();  
5.         p2.setVal(3.14);//Double  
6.           
7.         Person<String> p3 = new Person<>();  
8.         p3.setVal("007");//String  
9.         Person<Object> p4 = new Person<>();  
10.         p4.setVal(new Object());//Object  
11.   
12.         show(p1);//×  
13.         show(p2);//×  
14.         show(p3);//√  
15.         show(p4);//√  
16.     }  
17. public static void show(Person<? super String> p){//此处限定了Person的参数类型只能是String或者是其父类  
18.         System.out.println(p.getVal());  
19. }  

7.Collections类
此类是一个操作集合的工具类
常用方法:
static void reverse(List list):反转指定List集合中的顺序；（和ListItertor的逆序排列一样！）
static void shuffle(List list):对集合元素随机排序
static void sort(List list):自然升序排序
static vois swap(List list,int i, int j):将指定的List集合i处元素和j处元素进行交换；
static void rotate(List list, int distance):
若distance为正数，将list集合后的distance个元素移到前面；
当distance为负数，将list集合前的distance个元素移到后面；
static  int binarySearch(List list, Object key) 使用二分搜索法搜索指定列表，以获得指定对象。 
注意:调用之前 必须调用 Collections.sort(List list)(完成自然排序);


static Object max(Collection coll) 根据元素的自然顺序，返回给定 collection 的最大元素。   
static Object min(Collection coll) 根据元素的自然顺序，返回给定 collection 的最小元素。   
static  void fill(List list, Object obj)  使用指定元素替换指定列表中的所有元素。
static int frequency(Collection c, Object o)  返回指定 collection 中等于指定对象的元素数。 
static int indexOfSubList(Listsource, List target) 返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。 
static int lastIndexOfSubList(List source, List target)  返回指定源列表中最后一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。
static boolean  replaceAll(List list, Object oldVal, Object newVal)  使用另一个值替换列表中出现的所有某一指定值。

使用实例:

[java]  view plain copy

1. import static java.util.Collections.binarySearch;  
2. import static java.util.Collections.shuffle;  
3. import static java.util.Collections.sort;  
4. import java.util.ArrayList;  
5. import java.util.List;  
6.   
7. public class Test {  
8.     public static void main(String[] args) {  
9.         /** 
10.          * static int binarySearch(List list, Object ele) 使用二分搜索法搜索指定列表，以获得指定对象。 
11.          *  
12.          * static void sort(List<T> list) 根据元素的自然顺序 对指定列表按升序进行排序。 
13.          */  
14.         List list = new ArrayList();  
15.         list.add(1);  
16.         list.add(-3);  
17.         list.add(5);  
18.         list.add(-99);  
19.   
20.         System.out.println(list);  
21.         sort(list);  
22.         System.out.println(list);  
23.         int index = binarySearch(list, 0);  
24.         System.out.println(index);  
25.   
26.         /* 
27.          * static void copy(List dest, List src) 将所有元素从一个列表复制到另一个列表。 
28.          * static void fill(List list, Object obj) 使用指定元素替换指定列表中的所有元素。 
29.          * static boolean replaceAll(List list, Object oldVal, Object newVal) 
30.          * 使用另一个值替换列表中出现的所有某一指定值。 
31.          * static void shuffle(List list) 使用默认随机源对指定列表进行置换。 
32.          */  
33.         System.out.println("好的顺序" + list);  
34.         shuffle(list);  
35.         System.out.println("随机" + list);  
36.   
37.           
38.         //static void swap(List list, int i, int j) 在指定列表的指定位置处交换元素。  
39.     }  
40. }  

-----------android培训、java培训、期待与您交流！ ------------