有点迷糊
public int hashCode(){
    return this.name.hashCode()+this.age*17;
}
public boolean equals(Object obj){
  if (this ==obj) {
   return true;
  }
  if (!(this instanceof Student)){
   return false;
  }
  Student s = (Student) obj;
  return this.name.equals(s.name) && this.age == s.age;
}

有些可以自然排序。实际开发当然是根据需求自定义排序

同学，是HashMap为了保证为一性，必须写HashCode()和equals(),方法，而TreeMap是通过comparable和comparator接口来实现唯一性的。
通过comparator
public class TreeSetTest1 {
        public static void main(String[] args) {
                TreeSet<Student> tree = new TreeSet<Student>(new Comparator<Student>(){
                        @Override
                        public int compare(Student o1, Student o2) {
                                // TODO Auto-generated method stub
                                int num = o1.getName().length()-o2.getName().length();
                                int num2=(num==0)?(o1.getAge()-o2.getAge()):num;
                                int  num3=(num2==0)?o1.getName().compareTo(o2.getName()):num2;
                                return num3;
                        }
                });

还有一个是通过comparable
public class Person implements Comparable<Person>//注意实现接口。
@Override
        public int compareTo(Person p) {  //
               

TreeMap是以二叉树的结构形式来存储对象的；二叉树是一种有序的数据结构，为了保证有序，使用TreeMap有两种方式。

第一种方式是所存储的键类要实现Comparable接口，覆盖compareTo() 方法，即覆写 hashCode() 和 equals() 方法；

第二种方式是自定义一个比较器类，让这个比较器类实现Comparator接口，在实例化TreeMap对象时，把一个实例化的比较器类对象作为参数传递给TreeMap的构造函数。
第二种方式更为灵活，耦合性较低，实际开发中此种方式使用得比较多。

下面以自然排序为例

1. 
   
2. import java.util.*;
   
3. class R implements Comparable
   
4. {
   
5.         int count;
   
6.         public R(int count)
   
7.         {
   
8.                 this.count = count;
   
9.         }
   
10.         public String toString()
    
11.         {
    
12.                 return "R[count:" + count + "]";
    
13.         }
    
14.         //根据count来判断两个对象是否相等。
    
15.         public boolean equals(Object obj)
    
16.         {
    
17.                 if (this == obj)
    
18.                         return true;
    
19.                 if (obj!=null
    
20.                         && obj.getClass()==R.class)
    
21.                 {
    
22.                         R r = (R)obj;
    
23.                         return r.count == this.count;
    
24.                 }
    
25.                 return false;
    
26.         }
    
27.         //根据count属性值来判断两个对象的大小。
    
28.         public int compareTo(Object obj)
    
29.         {
    
30.                 R r = (R)obj;
    
31.                 return count > r.count ? 1 :
    
32.                         count < r.count ? -1 : 0;
    
33.         }
    
34. }
    
35. public class TreeMapTest
    
36. {
    
37.         public static void main(String[] args)
    
38.         {
    
39.                 TreeMap tm = new TreeMap();
    
40.                 tm.put(new R(3) , "轻量级Java EE企业应用实战");
    
41.                 tm.put(new R(-5) , "疯狂Java讲义");
    
42.                 tm.put(new R(9) , "疯狂Android讲义");
    
43.                 System.out.println(tm);
    
44.                 //返回该TreeMap的第一个Entry对象
    
45.                 System.out.println(tm.firstEntry());
    
46.                 //返回该TreeMap的最后一个key值
    
47.                 System.out.println(tm.lastKey());
    
48.                 //返回该TreeMap的比new R(2)大的最小key值。
    
49.                 System.out.println(tm.higherKey(new R(2)));
    
50.                 //返回该TreeMap的比new R(2)小的最大的key-value对。
    
51.                 System.out.println(tm.lowerEntry(new R(2)));
    
52.                 //返回该TreeMap的子TreeMap
    
53.                 System.out.println(tm.subMap(new R(-1) , new R(4)));
    
54.         }
    
55. }
    

复制代码

上面程序中定义了一个R类，该类重写了equals方法，并实现了Comparable接口，所以可以使用该R对象做为TreeMap的key，该key使用自然排序。
                                黑马云青年为您解答