java程序设计--孙鑫java无难事Lesson8《集合类》

java程序设计--孙鑫java无难事Lesson8《集合类》

本节要点: 集合类的操作和特性( 数据结构相关知识可参见《数据结构》教材,这部分知识,理论比较丰富, 在此略去 )
详细内容:

1.集合框架中的接口
Collection：集合层次中的根接口，JDK没有提供这个接口直接的实现类。
Set：不能包含重复的元素。SortedSet是一个按照升序排列元素的Set。
List：是一个有序的集合，可以包含重复的元素。提供了按索引访问的方式。

Map：包含了key-value对。Map不能包含重复的key。

SortedMap是一个按照升序排列key的Map。

集合类框架中的接口如下图所示:

2.集合框架中的实现类

集合框架中的实现类整齐层次如下图所示:

(1)ArrayList与LinkedList
ArrayList：
我们可以将ArrayList看作是能够自动增长容量的数组。
利用ArrayList的toArray()返回一个数组。
Arrays.asList()返回一个列表。
迭代器(Iterator) 给我们提供了一种通用的方式来访问集合中的元素。
LinkedList:
LinkedList是采用双向循环链表实现的。
利用LinkedList实现栈(stack)、队列(queue)、双向队列(double-ended queue )。

基于LinkedList的栈测试代码如下:

[java] view plain copy print ?

1. //基于LinkedList的栈测试   
2. import java.util.* ;  
3. class MyStack  
4. {     
5.     private LinkedList ll=new LinkedList();  
6.     public void push(Object o)  
7.     {  
8.          ll.addFirst(o);  
9.     }  
10.     public Object pop()  
11.     {  
12.       return ll.removeFirst();  
13.     }  
14.     public Object peek()  
15.     {  
16.       return ll.peekFirst();  
17.     }  
18.     public boolean empty()  
19.     {  
20.       return ll.isEmpty();  
21.     }  
22.     public static void main(String[] args)  
23.     {   MyStack ms=new MyStack();  
24.         ms.push("one");  
25.         ms.push("two");  
26.         ms.push("three");  
27.         System.out.println(ms.pop());  
28.         System.out.println(ms.peek());  
29.         System.out.println(ms.pop());  
30.         System.out.println(ms.empty());  
31.         //运行结果   
32.         /* 
33.         three 
34.         two 
35.         two 
36.         false */  
37.     }  
38. }  

//基于LinkedList的栈测试
import java.util.* ;
class MyStack
{   
    private LinkedList ll=new LinkedList();
    public void push(Object o)
    {
         ll.addFirst(o);
    }
    public Object pop()
    {
      return ll.removeFirst();
    }
    public Object peek()
    {
      return ll.peekFirst();
    }
    public boolean empty()
    {
      return ll.isEmpty();
    }
    public static void main(String[] args)
    {   MyStack ms=new MyStack();
        ms.push("one");
        ms.push("two");
        ms.push("three");
        System.out.println(ms.pop());
        System.out.println(ms.peek());
        System.out.println(ms.pop());
        System.out.println(ms.empty());
        //运行结果
        /*
        three
        two
        two
        false */
    }
}

基于LinkedList的队列测试代码如下:

[java] view plain copy print ?

1. //基于LinkedList的队列测试   
2. import java.util.*;  
3. class MyQueue  
4. {     
5.     private LinkedList ll=new LinkedList();  
6.     public void put(Object o)  
7.     {  
8.         ll.add(o);  
9.     }  
10.     public Object get()  
11.     {  
12.       return ll.removeFirst() ;  
13.     }  
14.     public boolean empty()  
15.     {  
16.       return ll.isEmpty();  
17.     }  
18.     public static void main(String[] args)  
19.     {     
20.         MyQueue mq=new MyQueue();  
21.         mq.put("one");  
22.         mq.put("two");  
23.         mq.put("three");  
24.         System.out.println(mq.get());  
25.         System.out.println(mq.get());  
26.         System.out.println(mq.get());  
27.         System.out.println(mq.empty());  
28.         //运行结果   
29.         /* 
30.         one 
31.         two 
32.         three 
33.         true    */  
34.     }  
35. }  

//基于LinkedList的队列测试
import java.util.*;
class MyQueue
{   
    private LinkedList ll=new LinkedList();
    public void put(Object o)
    {
        ll.add(o);
    }
    public Object get()
    {
      return ll.removeFirst() ;
    }
    public boolean empty()
    {
      return ll.isEmpty();
    }
    public static void main(String[] args)
    {   
        MyQueue mq=new MyQueue();
        mq.put("one");
        mq.put("two");
        mq.put("three");
        System.out.println(mq.get());
        System.out.println(mq.get());
        System.out.println(mq.get());
        System.out.println(mq.empty());
        //运行结果
        /*
        one
        two
        three
        true    */
    }
}

(2)Collections类
排序：Collections.sort()
（1）自然排寻(natural ordering )；（2）实现比较器(Comparator)接口。
取最大和最小的元素：Collections.max()、Collections.min()。
在已排序的List中搜索指定的元素：Collectons.binarySearch()。
自然排序、实现比较器接口、迭代器使用的测试代码如下:

[java] view plain copy print ?

1. import java.util.*;  
2. class ArrayListTest  
3. {     
4.     //迭代输出元素   
5.     public static void PrintElements(Collection e)  
6.     {  
7.        Iterator iter=e.iterator();  
8.        while(iter.hasNext())  
9.         {  
10.             System.out.println(iter.next());  
11.         }  
12.     }  
13.     public static void main(String[] args)  
14.     {     
15.         /* 
16.         //基本测试 
17.         ArrayList al=new ArrayList(); 
18.         al.add("java"); 
19.         al.add("ArrayList"); 
20.         al.add("Test"); 
21.         for(int i=0;i<al.size();i++) 
22.             System.out.println(al.get(i)); 
23.         System.out.println(al);//[java, ArrayList, Test]  调用ArrayList的toString方法 
24.         */  
25.   
26.         /* 
27.         //Collection.toArray和Arrays.asList转换测试 
28.  
29.         ArrayList al=new ArrayList(); 
30.         al.add("java"); 
31.         al.add("ArrayList"); 
32.         al.add("Test"); 
33.         Object[] objs=al.toArray();//列表转换为数组 
34.         for(int i=0;i<objs.length;i++) 
35.             System.out.println(objs[i]); 
36.         List ls=Arrays.asList(objs);//数组转换为列表  asList返回一个固定大小(a fixed-size)的列表 
37.         PrintElements(ls); 
38.         //ls.add("Add");//error  .UnsupportedOperationException  因为固定大小 
39.         */  
40.   
41.         /* 
42.         //迭代器使测试1 
43.         ArrayList al=new ArrayList(); 
44.         al.add("java"); 
45.         al.add("ArrayList"); 
46.         al.add("Test"); 
47.         Object[] objs=al.toArray(); 
48.         List ls=Arrays.asList(objs);//asList返回一个固定大小(a fixed-size)的列表 
49.         //Iterator iter=al.iterator();//ArrayList的迭代器 
50.         Iterator iter=ls.iterator();//List的迭代器 不支持remove方法  因为固定大小 
51.         iter.next(); 
52.         //iter.remove();//删除之前必须由next返回一个元素 
53.         while(iter.hasNext()) 
54.         { 
55.             System.out.println(iter.next()); 
56.         } 
57.         */  
58.   
59.         /* 
60.         //迭代器测试2 
61.         List ls=new ArrayList(); 
62.         ls.add("java"); 
63.         ls.add("ArrayList"); 
64.         ls.add("Test"); 
65.         Iterator iter=ls.iterator();//List的迭代器  此时支持remove方法  因为没有固定大小 
66.         iter.next(); 
67.         iter.remove(); 
68.         while(iter.hasNext()) 
69.         { 
70.             System.out.println(iter.next()); 
71.         } 
72.         */  
73.   
74.         /* 
75.         //排序测试代码 
76.         Student stu1=new Student(3,"ZhangSan"); 
77.         Student stu2=new Student(1,"LiSi"); 
78.         Student stu3=new Student(2,"ZhaoEr"); 
79.         Student stu4=new Student(2,"WangWu"); 
80.         ArrayList al=new ArrayList(); 
81.         al.add(stu1); 
82.         al.add(stu2); 
83.         al.add(stu3); 
84.         al.add(stu4); 
85.         */  
86.         //Collections.sort(al);//按自然顺序升序排列 必须实现Comparable接口   
87.         //自然排序运行结果   
88.         /* 
89.         num=1 name=LiSi 
90.         num=2 name=ZhaoEr 
91.         num=2 name=WangWu 
92.         num=3 name=ZhangSan 
93.         */  
94.         //Collections.sort(al,new Student.StudentComparator());//按指定Comparator的排序  必须实现Comparator接口   
95.         //指定comparator排序结果   
96.         /* 
97.         num=1 name=LiSi 
98.         num=2 name=WangWu 
99.         num=2 name=ZhaoEr 
100.         num=3 name=ZhangSan 
101.         */  
102.         //Collections.sort(al,Collections.reverseOrder());//反序排序 reverseOrder方法返回一个comparator   
103.         //逆序排序结果   
104.         /* 
105.         num=3 name=ZhangSan 
106.         num=2 name=ZhaoEr 
107.         num=2 name=WangWu 
108.         num=1 name=LiSi 
109.         */  
110.         //PrintElements(al);//迭代输出元素   
111.     }  
112. }  
113. class Student implements Comparable  
114. {  
115.     int num;  
116.     String name;  
117.     //利用内部类实现Comparator接口   
118.     static class StudentComparator implements Comparator  
119.     {  
120.         public int compare(Object o1,Object o2)  
121.         {  
122.            Student stu1=(Student)o1;  
123.            Student stu2=(Student)o2;  
124.            int ret=stu1.num>stu2.num?1:(stu1.num==stu2.num?0:-1);  
125.            if(ret==0)  
126.                 ret=stu1.name.compareTo(stu2.name);  
127.            return ret;  
128.         }  
129.         //注意:equals方法从Object类继承而来 因此可以不用实现equals方法   
130.     }  
131.     Student(int num,String name)  
132.     {  
133.       this.num=num;  
134.       this.name=name;  
135.     }  
136.     //实现Comparable接口   
137.     public int compareTo(Object o)  
138.     {  
139.         Student stu=(Student)o;  
140.         return this.num>stu.num?1:(this.num==stu.num?0:-1);  
141.     }  
142.     public String toString()  
143.     {  
144.        return "num="+num+" "+"name="+name;  
145.     }  
146. }  

import java.util.*;
class ArrayListTest
{   
    //迭代输出元素
    public static void PrintElements(Collection e)
    {
       Iterator iter=e.iterator();
       while(iter.hasNext())
        {
            System.out.println(iter.next());
        }
    }
    public static void main(String[] args)
    {   
        /*
        //基本测试
        ArrayList al=new ArrayList();
        al.add("java");
        al.add("ArrayList");
        al.add("Test");
        for(int i=0;i<al.size();i++)
            System.out.println(al.get(i));
        System.out.println(al);//[java, ArrayList, Test]  调用ArrayList的toString方法
        */

        /*
        //Collection.toArray和Arrays.asList转换测试

        ArrayList al=new ArrayList();
        al.add("java");
        al.add("ArrayList");
        al.add("Test");
        Object[] objs=al.toArray();//列表转换为数组
        for(int i=0;i<objs.length;i++)
            System.out.println(objs[i]);
        List ls=Arrays.asList(objs);//数组转换为列表  asList返回一个固定大小(a fixed-size)的列表
        PrintElements(ls);
        //ls.add("Add");//error  .UnsupportedOperationException  因为固定大小
        */

        /*
        //迭代器使测试1
        ArrayList al=new ArrayList();
        al.add("java");
        al.add("ArrayList");
        al.add("Test");
        Object[] objs=al.toArray();
        List ls=Arrays.asList(objs);//asList返回一个固定大小(a fixed-size)的列表
        //Iterator iter=al.iterator();//ArrayList的迭代器
        Iterator iter=ls.iterator();//List的迭代器 不支持remove方法  因为固定大小
        iter.next();
        //iter.remove();//删除之前必须由next返回一个元素
        while(iter.hasNext())
        {
            System.out.println(iter.next());
        }
        */

        /*
        //迭代器测试2
        List ls=new ArrayList();
        ls.add("java");
        ls.add("ArrayList");
        ls.add("Test");
        Iterator iter=ls.iterator();//List的迭代器  此时支持remove方法  因为没有固定大小
        iter.next();
        iter.remove();
        while(iter.hasNext())
        {
            System.out.println(iter.next());
        }
        */

        /*
        //排序测试代码
        Student stu1=new Student(3,"ZhangSan");
        Student stu2=new Student(1,"LiSi");
        Student stu3=new Student(2,"ZhaoEr");
        Student stu4=new Student(2,"WangWu");
        ArrayList al=new ArrayList();
        al.add(stu1);
        al.add(stu2);
        al.add(stu3);
        al.add(stu4);
        */
        //Collections.sort(al);//按自然顺序升序排列 必须实现Comparable接口
        //自然排序运行结果
        /*
        num=1 name=LiSi
        num=2 name=ZhaoEr
        num=2 name=WangWu
        num=3 name=ZhangSan
        */
        //Collections.sort(al,new Student.StudentComparator());//按指定Comparator的排序  必须实现Comparator接口
        //指定comparator排序结果
        /*
        num=1 name=LiSi
        num=2 name=WangWu
        num=2 name=ZhaoEr
        num=3 name=ZhangSan
        */
        //Collections.sort(al,Collections.reverseOrder());//反序排序 reverseOrder方法返回一个comparator
        //逆序排序结果
        /*
        num=3 name=ZhangSan
        num=2 name=ZhaoEr
        num=2 name=WangWu
        num=1 name=LiSi
        */
        //PrintElements(al);//迭代输出元素
    }
}
class Student implements Comparable
{
    int num;
    String name;
    //利用内部类实现Comparator接口
    static class StudentComparator implements Comparator
    {
        public int compare(Object o1,Object o2)
        {
           Student stu1=(Student)o1;
           Student stu2=(Student)o2;
           int ret=stu1.num>stu2.num?1:(stu1.num==stu2.num?0:-1);
           if(ret==0)
                ret=stu1.name.compareTo(stu2.name);
           return ret;
        }
        //注意:equals方法从Object类继承而来 因此可以不用实现equals方法
    }
    Student(int num,String name)
    {
      this.num=num;
      this.name=name;
    }
    //实现Comparable接口
    public int compareTo(Object o)
    {
        Student stu=(Student)o;
        return this.num>stu.num?1:(this.num==stu.num?0:-1);
    }
    public String toString()
    {
       return "num="+num+" "+"name="+name;
    }
}

(3)HashSet与HashMap
HashSet:实现Set接口的hash table(哈希表)，依靠HashMap来实现的。我们应该为要存放到散列表的各个对象定义hashCode()和equals()。
HashMap:
HashMap对key进行散列。

keySet()、values()、entrySet()。

HashSet和HashMap测试代码如下:

[java] view plain copy print ?

1. //HashSet测试代码   
2. import java.util.* ;  
3. class HashSetTest  
4. {  
5.     public static void main(String[] args)  
6.     {     
7.           
8.         /* 
9.         //基本测试 
10.         HashSet hs=new HashSet(); 
11.         hs.add("one"); 
12.         hs.add("two"); 
13.         hs.add("three"); 
14.         hs.add("four"); 
15.         hs.add("one");//不能重复元素  将无法保存重复元素 
16.         Iterator iter=hs.iterator(); 
17.         while(iter.hasNext()) 
18.           System.out.println(iter.next()); 
19.         */  
20.         //哈希码计算的测试  hashCode方法实现   
21.         HashSet hs=new HashSet();  
22.         hs.add(new Student(1,"ZhangSan"));  
23.         hs.add(new Student(2,"LiSi"));  
24.         hs.add(new Student(3,"WangWu"));  
25.         //根据对象的散列码计算 new产生不同对象   
26.         //因此hashset认为是两个不同的对象 存贮了两个对象 虽然是重复的   
27.         hs.add(new Student(1,"ZhangSan"));    
28.         Iterator iter=hs.iterator();  
29.         while(iter.hasNext())  
30.           System.out.println(iter.next());  
31.           
32.        //未实现Student类的hasCode和equals方法时 运行结果   
33.         /* 
34.         num=2 name LiSi 
35.         num=1 name ZhangSan 
36.         num=1 name ZhangSan 
37.         num=3 name WangWu 
38.         */  
39.         //实现了Student类的hasCode和equals方法时运行结果   
40.         /* 
41.         num=2 name LiSi 
42.         num=1 name ZhangSan 
43.         num=3 name WangWu 
44.         */  
45.     }  
46. }  
47. class Student  
48. {  
49.     int num;  
50.     String name;  
51.     Student(int num,String name)  
52.     {  
53.       this.num=num;  
54.       this.name=name;  
55.     }  
56.     //需要覆盖hashCode和equals方法   
57.     public  int hashCode()  
58.     {  
59.         return num*(name.hashCode());  
60.     }  
61.     public boolean equals(Object o)  
62.     {  
63.         Student stu=(Student)o;  
64.         return this.num==stu.num && this.name.equals(stu.name);  
65.     }  
66.       
67.     public String toString()  
68.     {  
69.        return "num="+num+" "+"name"+" "+name;  
70.     }  
71. }  
72.    

//HashSet测试代码
import java.util.* ;
class HashSetTest
{
    public static void main(String[] args)
    {   
        
        /*
        //基本测试
        HashSet hs=new HashSet();
        hs.add("one");
        hs.add("two");
        hs.add("three");
        hs.add("four");
        hs.add("one");//不能重复元素  将无法保存重复元素
        Iterator iter=hs.iterator();
        while(iter.hasNext())
          System.out.println(iter.next());
        */
        //哈希码计算的测试  hashCode方法实现
        HashSet hs=new HashSet();
        hs.add(new Student(1,"ZhangSan"));
        hs.add(new Student(2,"LiSi"));
        hs.add(new Student(3,"WangWu"));
        //根据对象的散列码计算 new产生不同对象
        //因此hashset认为是两个不同的对象 存贮了两个对象 虽然是重复的
        hs.add(new Student(1,"ZhangSan"));  
        Iterator iter=hs.iterator();
        while(iter.hasNext())
          System.out.println(iter.next());
        
       //未实现Student类的hasCode和equals方法时 运行结果
        /*
        num=2 name LiSi
        num=1 name ZhangSan
        num=1 name ZhangSan
        num=3 name WangWu
        */
        //实现了Student类的hasCode和equals方法时运行结果
        /*
        num=2 name LiSi
        num=1 name ZhangSan
        num=3 name WangWu
        */
    }
}
class Student
{
    int num;
    String name;
    Student(int num,String name)
    {
      this.num=num;
      this.name=name;
    }
    //需要覆盖hashCode和equals方法
    public  int hashCode()
    {
        return num*(name.hashCode());
    }
    public boolean equals(Object o)
    {
        Student stu=(Student)o;
        return this.num==stu.num && this.name.equals(stu.name);
    }
    
    public String toString()
    {
       return "num="+num+" "+"name"+" "+name;
    }
}
 

[java] view plain copy print ?

1. //HashMap测试代码   
2. import java.util.* ;  
3. class HashMapTest  
4. {     
5.     public static void PrintElements(Collection e)  
6.     {  
7.        Iterator iter=e.iterator();  
8.        while(iter.hasNext())  
9.         {  
10.             System.out.println(iter.next());  
11.         }  
12.     }  
13.     public static void main(String[] args)  
14.     {     
15.         HashMap  hm= new HashMap();  
16.         hm.put(1,"ZhangSan");  
17.         hm.put(2,"LiSi");  
18.         hm.put(3,"WangWu");  
19.         //由键获取键值   
20.         System.out.println("values getted from key:");  
21.         System.out.println(hm.get(1));  
22.         System.out.println(hm.get(2));  
23.         System.out.println(hm.get(3));  
24.         //获取键视图   
25.         Set keys=hm.keySet();  
26.         System.out.println("keys view:");  
27.         PrintElements(keys);  
28.         //获取值视图   
29.         Collection values=hm.values();  
30.         System.out.println("values view:");  
31.         PrintElements(values);  
32.         //获取键值对   
33.         Set Entries =hm.entrySet();  
34.         System.out.println("Entries:");  
35.         PrintElements(Entries);  
36.         //迭代Entries   
37.         Iterator iter=Entries.iterator();  
38.         System.out.println("keys and values in Entries:");  
39.         while(iter.hasNext())  
40.         {     
41.             Map.Entry en= (Map.Entry)iter.next();  
42.             System.out.println(en.getKey()+":"+en.getValue());  
43.         }  
44.         /* 
45.         //运行结果 
46.         values getted from key: 
47.         ZhangSan 
48.         LiSi 
49.         WangWu 
50.         keys view: 
51.         1 
52.         2 
53.         3 
54.         values view: 
55.         ZhangSan 
56.         LiSi 
57.         WangWu 
58.         Entries: 
59.         1=ZhangSan 
60.         2=LiSi 
61.         3=WangWu 
62.         keys and values in Entries: 
63.         1:ZhangSan 
64.         2:LiSi 
65.         3:WangWu 
66.         */  
67.     }  
68. }  

//HashMap测试代码
import java.util.* ;
class HashMapTest
{   
    public static void PrintElements(Collection e)
    {
       Iterator iter=e.iterator();
       while(iter.hasNext())
        {
            System.out.println(iter.next());
        }
    }
    public static void main(String[] args)
    {   
        HashMap  hm= new HashMap();
        hm.put(1,"ZhangSan");
        hm.put(2,"LiSi");
        hm.put(3,"WangWu");
        //由键获取键值
        System.out.println("values getted from key:");
        System.out.println(hm.get(1));
        System.out.println(hm.get(2));
        System.out.println(hm.get(3));
        //获取键视图
        Set keys=hm.keySet();
        System.out.println("keys view:");
        PrintElements(keys);
        //获取值视图
        Collection values=hm.values();
        System.out.println("values view:");
        PrintElements(values);
        //获取键值对
        Set Entries =hm.entrySet();
        System.out.println("Entries:");
        PrintElements(Entries);
        //迭代Entries
        Iterator iter=Entries.iterator();
        System.out.println("keys and values in Entries:");
        while(iter.hasNext())
        {   
            Map.Entry en= (Map.Entry)iter.next();
            System.out.println(en.getKey()+":"+en.getValue());
        }
        /*
        //运行结果
        values getted from key:
        ZhangSan
        LiSi
        WangWu
        keys view:
        1
        2
        3
        values view:
        ZhangSan
        LiSi
        WangWu
        Entries:
        1=ZhangSan
        2=LiSi
        3=WangWu
        keys and values in Entries:
        1:ZhangSan
        2:LiSi
        3:WangWu
        */
    }
}

(4)TreeSet与TreeMap
TreeSet:
TreeSet是依靠TreeMap来实现的。
TreeSet是一个有序集合，TreeSet中元素将按照升序排列，缺省是按照自然顺序进行排列，意味着TreeSet中元素要实现Comparable接口。
我们可以在构造TreeSet对象时，传递实现了Comparator接口的比较器对象。
TreeMap:TreeMap按照key进行排序。

TreeSet测试代码如下:

[java] view plain copy print ?

1. //TreeSet测试代码   
2. import java.util.* ;  
3. class TreeSetTest  
4. {  
5.     public static void main(String[] args)  
6.     {     
7.         /* 
8.         //基本使用 
9.         TreeSet ts=new TreeSet(); 
10.         ts.add("java"); 
11.         ts.add("TreeSet"); 
12.         ts.add("Test"); 
13.         Iterator iter=ts.iterator(); 
14.         while(iter.hasNext()) 
15.             System.out.println(iter.next()); 
16.         */  
17.           
18.         //由指定比较器构造TreeSet   
19.         TreeSet ts=new TreeSet(new Student.StudentComparator());  
20.         ts.add(new Student(3,"ZhangSan"));  
21.         ts.add(new Student(1,"LiSi"));  
22.         ts.add(new Student(2,"ZhaoEr"));  
23.         ts.add(new Student(2,"WangWu"));  
24.         Iterator iter=ts.iterator();  
25.         while(iter.hasNext())  
26.             System.out.println(iter.next());  
27.     }  
28. }  
29. class Student  
30. {  
31.     int num;  
32.     String name;  
33.     //实现比较器   
34.     static class StudentComparator implements Comparator  
35.     {  
36.         public int compare(Object o1,Object o2)  
37.         {  
38.            Student stu1=(Student)o1;  
39.            Student stu2=(Student)o2;  
40.            int ret=stu1.num>stu2.num?1:(stu1.num==stu2.num?0:-1);  
41.            if(ret==0)  
42.                 ret=stu1.name.compareTo(stu2.name);  
43.            return ret;  
44.         }  
45.         //equals方法从Object类继承而来 因此可以不用实现这个方法   
46.     }  
47.     Student(int num,String name)  
48.     {  
49.       this.num=num;  
50.       this.name=name;  
51.     }  
52.     public String toString()  
53.     {  
54.        return "num="+num+" "+"name="+name;  
55.     }  
56. }  

//TreeSet测试代码
import java.util.* ;
class TreeSetTest
{
    public static void main(String[] args)
    {   
        /*
        //基本使用
        TreeSet ts=new TreeSet();
        ts.add("java");
        ts.add("TreeSet");
        ts.add("Test");
        Iterator iter=ts.iterator();
        while(iter.hasNext())
            System.out.println(iter.next());
        */
        
        //由指定比较器构造TreeSet
        TreeSet ts=new TreeSet(new Student.StudentComparator());
        ts.add(new Student(3,"ZhangSan"));
        ts.add(new Student(1,"LiSi"));
        ts.add(new Student(2,"ZhaoEr"));
        ts.add(new Student(2,"WangWu"));
        Iterator iter=ts.iterator();
        while(iter.hasNext())
            System.out.println(iter.next());
    }
}
class Student
{
    int num;
    String name;
    //实现比较器
    static class StudentComparator implements Comparator
    {
        public int compare(Object o1,Object o2)
        {
           Student stu1=(Student)o1;
           Student stu2=(Student)o2;
           int ret=stu1.num>stu2.num?1:(stu1.num==stu2.num?0:-1);
           if(ret==0)
                ret=stu1.name.compareTo(stu2.name);
           return ret;
        }
        //equals方法从Object类继承而来 因此可以不用实现这个方法
    }
    Student(int num,String name)
    {
      this.num=num;
      this.name=name;
    }
    public String toString()
    {
       return "num="+num+" "+"name="+name;
    }
}

(5)几种类的比较
ArrayList和LinkedList的比较：
ArrayList底层采用数组完成，而LinkedList则是以一般的双向链表(double-linked list)完成，其内每个对象除了数据本身外，还有两个 引用，分别指向前一个元素和后一个元素。
如果我们经常在List的开始处增加元素，或者在List中进行插入和删除操作，我们应该使用LinkedList，否则的话，使用ArrayList将更加快速。
HashSet和TreeSet的比较:
HashSet是基于Hash算法实现的，其性能通常都优于TreeSet。我们通常都应该使用HashSet，在我们需要排序的功能时，我们才使用TreeSet。
HashMap和TreeMap的比较:
和Set类似，HashMap的速度通常都比TreeMap快，只有在需要排序的功能的时候，才使用TreeMap。
3.properties类
新建一个配置文件如下图所示:

新建PropTest 测试代码如下:

[java] view plain copy print ?

1. //properties类测试代码   
2. import java.util.*;  
3. import java.io.*;  
4. class PropTest  
5. {  
6.     public static void main(String[] args)  
7.     {          
8.         /* 
9.         //获取当前系统属性 
10.         //Properties prop=System.getProperties(); 
11.         //prop.list(System.out); 
12.         */  
13.         //读取ini配置文件信息   
14.          Properties pps=new Properties();  
15.          try  
16.          {  
17.             pps.load(new FileInputStream("Propini.ini"));//从输入流中读取属性列表 列表由键值对组成   
18.             //获取ini文件中键的枚举   
19.             Enumeration er=pps.propertyNames();  
20.             while(er.hasMoreElements())  
21.              {  
22.                 String key=(String)er.nextElement();  
23.                 System.out.println(key+"="+pps.getProperty(key));  
24.              }  
25.          }  
26.          catch (Exception e)  
27.          {  
28.              e.printStackTrace();  
29.          }  
30.     }  
31. }  

//properties类测试代码
import java.util.*;
import java.io.*;
class PropTest
{
    public static void main(String[] args)
    {        
        /*
        //获取当前系统属性
        //Properties prop=System.getProperties();
        //prop.list(System.out);
        */
        //读取ini配置文件信息
         Properties pps=new Properties();
         try
         {
            pps.load(new FileInputStream("Propini.ini"));//从输入流中读取属性列表 列表由键值对组成
            //获取ini文件中键的枚举
            Enumeration er=pps.propertyNames();
            while(er.hasMoreElements())
             {
                String key=(String)er.nextElement();
                System.out.println(key+"="+pps.getProperty(key));
             }
         }
         catch (Exception e)
         {
             e.printStackTrace();
         }
    }
}

//运行结果
university=HBNU
department=CS
class=0801