1. import java.util.*;
   
2. import java.util.TreeSet;
   
3. 
   
4. class Student implements Comparable<Student>
   
5. {
   
6.         private String name;
   
7.         private int age;
   
8. 
   
9.         Student(String name, int age)
   
10.         {
    
11.                 this.name = name;
    
12.                 this.age = age;
    
13.         }
    
14. 
    
15.         public int compareTo(Student s)
    
16.         {
    
17.                 int num = new Integer(this.age).compareTo(new Integer(s.age));
    
18.                 if(num==0)
    
19.                         return this.name.compareTo(s.name);
    
20.                 return num;
    
21.         }
    
22.         public int hashCode()
    
23.         {
    
24.                 return name.hashCode()+age*34;
    
25.         }
    
26.         
    
27.         public boolean equals(Object obj)
    
28.         {
    
29.                 if(!(obj instanceof Student))
    
30.                         throw new ClassCastException("leixing bu pipei");
    
31.                 Student s = (Student)obj;
    
32.                 return this.name.equals(s.name)&&this.age==s.age;
    
33.         }
    
34.         public String getName()
    
35.         {
    
36.                 return name;
    
37.         }
    
38.         public int getAge()
    
39.         {
    
40.                 return age;
    
41.         }
    
42.         public String toString()
    
43.         {
    
44.                 return name+":"+age;
    
45.         }
    
46. }
    
47. class  MapTest
    
48. {
    
49.         public static void main(String[] args)
    
50.         {
    
51.                 HashMap<Student,String> hm = new HashMap<Student,String>();
    
52. 
    
53.                 hm.put(new Student("list1",21),"beijing");
    
54.                 hm.put(new Student("list1",21),"tianjin");
    
55.                 hm.put(new Student("list2",22),"shanghai");
    
56.                 hm.put(new Student("list3",23),"nanjing");
    
57.                 hm.put(new Student("list4",24),"wuhan");
    
58. /*                //第一种取出方式 ：keySet
    
59.                 //先获取map集合的所有键的Set集合,keySet();
    
60.                 Set<Student> keySet = hm.keySet();
    
61. 
    
62.                 //有了Set集合。就可以获取其迭代器。
    
63.                 Iterator<Student> it = keySet.iterator();
    
64.                         
    
65.                 while (it.hasNext())
    
66.                 {
    
67.                         Student stu = it.next();
    
68.                         //有了键可通过map集合get方法获取对应的值。
    
69.                         String addr = hm.get(stu);        
    
70.                         System.out.println(stu+".."+addr);
    
71.                 }
    
72. */
    
73.                 //第二种方式： EntrySet
    
74.                 //将Map集合中的映射关系取出。存入到Set集合中
    
75.                 Set<Map.Entry<Student,String>> entrySet = hm.entrySet();
    
76.                         
    
77.                 //TreeSet<Map.Entry<Student,String>> treeSet = new TreeSet<Map.Entry<Student,String>>(hm);
    
78.                
    
79.                 Iterator<Map.Entry<Student,String>> it = entrySet.iterator();
    
80. 
    
81.                 while (it.hasNext())
    
82.                 {
    
83.                         Map.Entry<Student,String> me = it.next();
    
84. 
    
85.                         Student stu = me.getKey();
    
86.                         String addr = me.getValue();
    
87.                         System.out.println(stu+"::::::::"+addr);
    
88.                 }
    
89.         }
    
90.         
    
91. }
    

复制代码

本例中如何使用TreeSet（）排序？改动可以，关键是 以实现 compareble的方式来排序，而非定义比较器。

//TreeSet<Map.Entry<Student,String>> treeSet = new TreeSet<Map.Entry<Student,String>>(hm);
这句是错误的。

TreeSet(Collection<? extends E> c)
构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。

为什么不可以？   

TreeSet接收的集合必须具备比较性，而Map.Entry不具备比较性，所以不能拿TreeSet接收。
要实现排序就把HashMap改为TreeMap，就能利用实现了Comparable接口的Student自身来排序了。因为hashmap是无序的。

第一个问题：如何使用TreeSet（）排序？你比较写的也正确，只是在后边遍历时整错，还有就是比较器代码觉得可改进，可参考：
我写的比较方法如下：

1.         public int compareTo(Student s) {
   
2.                 // int num = this.name.compareTo(s.name);
   
3.                 // return num == 0 ? this.age - s.age : num;
   
4.                 int num = this.age - s.age;
   
5.                 return num == 0 ? this.name.compareTo(s.name) : num;
   
6.                 // return this.age - s.age;
   
7.         }

复制代码

遍历代码：

1. public class TreeSetDemo2 {
   
2.         public static void main(String[] args) {
   
3.                 TreeSet<Student> ts = new TreeSet<Student>();
   
4. 
   
5.                 Student s1 = new Student("李白", 28);
   
6.                 Student s2 = new Student("杜甫", 25);
   
7.                 Student s3 = new Student("李白", 28);
   
8.                 Student s4 = new Student("白居易", 23);
   
9.                 Student s5 = new Student("杜甫", 25);
   
10.                 Student s6 = new Student("李清照", 25);
    
11.                 Student s7 = new Student("李照", 35);
    
12.                 Student s8 = new Student("李", 27);
    
13. 
    
14.                 ts.add(s1);
    
15.                 ts.add(s2);
    
16.                 ts.add(s3);
    
17.                 ts.add(s4);
    
18.                 ts.add(s5);
    
19.                 ts.add(s6);
    
20.                 ts.add(s7);
    
21.                 ts.add(s8);
    
22. 
    
23.                 Iterator<Student> it = ts.iterator();
    
24.                 while (it.hasNext()) {
    
25.                         Student s = it.next();
    
26.                         System.out.println(s.getName() + "***" + s.getAge());
    
27.                 }
    
28.         }
    
29. }

复制代码

存放具有比较性的元素你用HashSet那不是没事找事么，要不人家定义一个TreeSet干嘛呢 这两的用处区别就在这里 如果存的元素需要有比较性 就用TreeSet。不需要元素具有比较性时首选HashSet  这个效率会相对高一些

HM朱俊 发表于 2013-4-6 20:29
TreeSet接收的集合必须具备比较性，而Map.Entry不具备比较性，所以不能拿TreeSet接收。
要实现排序就把Hash ...

谢谢   改为TreeMap可以的  
且无需复写 equals()  hashCode()

能否简要说下 TreeMap如何实现排序的？

由对象实现Comparable接口或集合实现Comparator接口的CompareTo()方法，从而实现排序
如下例：实现了Comparable接口

1. public class TreeMapDemo {
   
2.         public static void main(String[] args) {
   
3.                 TreeMap<Student, String> tm = new TreeMap<Student, String>(new Comparator<Student>() {
   
4.                         @Override
   
5.                         public int compare(Student s1, Student s2) {
   
6.                                 int num = s1.getAge() - s2.getAge();
   
7.                                 return num == 0 ? s1.getName().compareTo(s2.getName()) : num;
   
8.                         }
   
9.                 });
   
10. 
    
11.                 Student s1 = new Student("上官金红", 40);
    
12.                 Student s2 = new Student("李寻欢", 28);
    
13.                 Student s3 = new Student("天机老人", 36);
    
14.                 Student s4 = new Student("阿飞", 32);
    
15. 
    
16.                 tm.put(s1, "北京");
    
17.                 tm.put(s2, "上海");
    
18.                 tm.put(s3, "钓鱼岛");
    
19.                 tm.put(s4, "香港");
    
20. 
    
21.                 Set<Student> set = tm.keySet();
    
22.                 Iterator<Student> it = set.iterator();
    
23.                 while (it.hasNext()) {
    
24.                         Student key = it.next();
    
25.                         String value = tm.get(key);
    
26.                         System.out.println(key.getName() + "***" + key.getAge() + "***" + value);
    
27.                 }
    
28.         }

复制代码

騛鹏 发表于 2013-4-6 20:54
谢谢   改为TreeMap可以的  
且无需复写 equals()  hashCode()

TreeMap是根据该映射关系中键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。跟TreeSet原理一样的。如果键不具备比较性就要让元素实现Comparable接口覆盖compareTo方法，或者定义一个比较器是覆盖Comparetor中的compare方法

HM朱俊 发表于 2013-4-6 21:16
TreeMap是根据该映射关系中键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体 ...

谢谢  同样谢谢楼上的回复者