TreeMap                     
hashMap  
这2中在排序的，时候，都是靠什么条件来排的呢，
如果类实现了，comparable，是先靠他自身条件排，还是，先靠依靠comparable 呢？

有点理不清楚了

HashMap: 最常用的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值，具有很快的访问速度。HashMap最多只允许一条记录的键为Null(多条会覆盖);允许多条记录的值为 Null。非同步的。HashMap是按照HashCode 排序的。
TreeMap: 能够把它保存的记录根据键(key)排序,默认是按升序排序，也可以指定排序的比较器，当用Iterator 遍历TreeMap时，得到的记录是排过序的。TreeMap不允许key的值为null。非同步的。
TreeMap默认按key进行升序排序，如果想改变默认的顺序，可以使用比较器:

1. Map<String,String> map = new TreeMap<String,String>(new Comparator<String>(){
   
2.    public int compare(String obj1,String obj2){
   
3.     //降序排序
   
4.     return obj2.compareTo(obj1);
   
5.    }
   
6.   });
   
7.   map.put("month", "The month");
   
8.   map.put("bread", "The bread");
   
9.   map.put("attack", "The attack");
   
10.   
    
11.   Set<String> keySet = map.keySet();
    
12.   Iterator<String> iter = keySet.iterator();
    
13.   while(iter.hasNext()){
    
14.    String key = iter.next();
    
15.    System.out.println(key+":"+map.get(key));
    
16.   }

复制代码

如果类实现了comparable，表示强行对实现它的每个类的对象进行整体排序，实现此接口的对象列表（和数组）可以通过Collections.sort或Arrays.sort进行自动排序。

1. public class User implements Comparable {  
   
2.   
   
3.   private String id;  
   
4.   private int age;  
   
5.   
   
6.   public User(String id, int age) {  
   
7.     this.id = id;  
   
8.     this.age = age;  
   
9.   }  
   
10.   
    
11.   public int getAge() {  
    
12.     return age;  
    
13.   }  
    
14.   
    
15.   public void setAge(int age) {  
    
16.     this.age = age;  
    
17.   }  
    
18.   
    
19.   public String getId() {  
    
20.     return id;  
    
21.   }  
    
22.   
    
23.   public void setId(String id) {  
    
24.     this.id = id;  
    
25.   }  
    
26.   
    
27.   public int compareTo(Object o) {  
    
28.     return this.age - ((User) o).getAge();  
    
29.   }  
    
30.   
    
31.   /**
    
32.    * 测试方法
    
33.    */  
    
34.   public static void main(String[] args) {  
    
35.     User[] users = new User[] { new User("a", 30), new User("b", 20) };  
    
36.     Arrays.sort(users);  
    
37.     for (int i = 0; i < users.length; i++) {  
    
38.       User user = users[i];  
    
39.       System.out.println(user.getId() + " " + user.getAge());  
    
40.     }  
    
41.   }  
    
42.   
    
43. }  

复制代码

一个类实现了Camparable接口则表明这个类的对象之间是可以相互比较的，这个类对象组成的集合就可以直接使用sort方法排序。

首先hashmap是不具备排序功能的。
对于treeMap的排序，所谓的排序指的是对key的排序，有两种方式：
1、往treeMap中存放的元素有比较性，常做的操作是元素对应的类实现Compareable,如：
treeMap集合中存放学生，学生类实现Compareable接口,按照学生年龄排序，年龄相同时按照姓名自然顺序排序
TreeSet<Student> tr = new TreeSet<Student>();
tr.add(new Student("lisi01",11));
tr.add(new Student("lisi02",12));
class Student implements Comparable{
...
//实现compareTo方法
public int compareTo(Object obj)
        {
                if(!(obj instanceof Student))
                        throw new RuntimeException("类型不匹配");

                Student s = (Student)obj;
                System.out.println(this.name+"..."+s.name);
                int num = new Integer(this.age).compareTo(new Integer(s.age));
                if(num==0)
                        return this.name.compareTo(s.name);
                return num;
        }
...
}

2、定义比较器Comparator，将Comparator作为参数传入treeMap的构造函数中，使得treeMap要存放的元素按照Comparator定义的规则排序。
定义比较器，按照学生年龄排序，年龄相同时按照姓名自然顺序排序
TreeSet<Student> tr = new TreeSet<Student>(new MyComparator());
tr.add(new Student("lisi01",11));
tr.add(new Student("lisi02",12));

class MyComparator implements Comparator{
        
        public int compare(Object o1, Object o2){
                Student s1 = (Student)o1;
                Student s2 = (Student)o2;
                int n = new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
                if(n==0){
                        return new Integer(s1.getName()).compareTo(new Integer(s2.getName()));
                }
                return n;
        }
}

当存在比较器和并且类实现了Compareable时，以比较器的规则为主。