TreeMap   中的Key 值 是自动排序的吗？是添加一个就排一次的吗？按照什么规律？要是自定义应该怎么定义？
HsahMap  中的Key 值 可以排训吗？怎么排？

1.HashMap<key,value> 如果key 是包装类（Integer Double等）类型或者String类型 由于包装类和String类的对象本身具有比较性，添加到TreeMap里会自动排序，每添加一个排序一个。

2 为什么能对key进行排序呢,这个与TreeMap集合的数据存储结构有关，TreeMap是采用二叉树的数据存储结构的，每添加一个元素，就比较一下，被添加的元素如果小于该元素，添加到该元素的左子树，反之则添加到右子树。对二叉树进行遍历的时候，采用中序遍历，就得到了有序的元素集合。

3.自定义类要让TreeMap的key能进行排序 要么让key的对象具有比较性（实现Comparable接口让对象具有比较性），要么让集合具有比较性（定义外部比较器，即实现Comparator接口，然后将比较器通过TreeMap的构造函数传入，让集合具有比较性，从而达到排序目的。）  详细见代码。。。

4.HashMap 不会对Key进行排序的，这是因为HashMap 采用的哈希存储结构。

1. import java.util.*;
   
2. public class HashMapDemo
   
3. {
   
4. 
   
5. 
   
6.         public static void main(String[] args)
   
7.         {
   
8.                 HashMap<String, String> map=new HashMap<String, String>();
   
9.                 map.put("1", "11111");
   
10.                 map.put("4", "44444");
    
11.                 map.put("3", "33333");
    
12.                 map.put("2", "22222");
    
13.                 map.put("5", "55555");
    
14.                 //遍历集合的内容
    
15.                 for(Map.Entry<String,String> me:map.entrySet())
    
16.                 {
    
17.                         System.out.println(me.getKey()+"--->"+me.getValue());
    
18.                 }
    
19. 
    
20.         }
    
21. 
    
22. }

复制代码

以上代码输出结果是Key是无序的

HashMap自定义类的key 如何排序：

1. import java.util.*;
   
2. public class TreeMapDemo
   
3. {
   
4. 
   
5.        
   
6.         public static void main(String[] args)
   
7.         {
   
8.        
   
9.                 TreeMap<Person,String> map=new TreeMap<Person, String>();
   
10.        
    
11.                
    
12. 
    
13.                
    
14.                 map.put(new Person("tom",20), "美国佬");
    
15.                 map.put(new Person("lily",15), "英国妞");
    
16.                 map.put(new Person("lulu",10), "日本女");
    
17.                 map.put(new Person("rose",18), "德国mm");
    
18. 
    
19.                
    
20.                
    
21.                
    
22.                 //遍历集合的内容
    
23.                 for(Map.Entry<Person,String> me:map.entrySet())
    
24.                 {
    
25.                         System.out.println(me.getKey()+"--->"+me.getValue());
    
26.                 }
    
27. 
    
28.         }
    
29. 
    
30. }
    
31. 
    
32. /*
    
33. * 自定义类可以实现Comparable接口让对象具有比较性，从而达到排序的目的
    
34. 另外还可以自定义外部比较器，即实现Comparator接口，
    
35. 然后将比较器通过TreeMap的构造函数传入，让集合具有比较性，从而达到排序目的。
    
36. */
    
37. class Person implements Comparable<Person>
    
38. {
    
39.         String name;
    
40.         int age;
    
41.         Person(String name,int age)
    
42.         {
    
43.                 this.name=name;
    
44.                 this.age=age;
    
45.         }
    
46.        
    
47.         public String toString()//重写toString 方法
    
48.         {
    
49.                 return "姓名："+this.name+" 年龄："+this.age;
    
50.         }
    
51. 
    
52.     //按照年龄进行排序
    
53.         public int compareTo(Person p)
    
54.         {
    
55.                 if(this.age>p.age)
    
56.                         return 1;
    
57.                 if(this.age<p.age)
    
58.                         return -1;
    
59.                 return 0;
    
60.         }
    
61. 
    
62. }

复制代码

输出结果：（按key中的年龄排序）

姓名：lulu 年龄：10--->日本女
姓名：lily 年龄：15--->英国妞
姓名：rose 年龄：18--->德国mm
姓名：tom 年龄：20--->美国佬



TreeMap中如果key是包装类或者String类会自动进行key排序（包装类或者String类的对象都有比较性）

1. import java.util.*;
   
2. public class TreeMapDemo11
   
3. {
   
4. 
   
5. 
   
6.         public static void main(String[] args)
   
7.         {
   
8.           TreeMap<Integer,String> map=new TreeMap<Integer, String>();
   
9.           
   
10.           map.put(2, "222");
    
11.           map.put(5, "555");
    
12.           map.put(3, "333");
    
13.           map.put(4, "444");
    
14.           map.put(1, "111");
    
15.           
    
16.           //遍历结合的内容
    
17.           for (Map.Entry<Integer, String> me:map.entrySet())
    
18.                 {
    
19.                   System.out.println(me.getKey()+"--->"+me.getValue());
    
20.                 }
    
21.           
    
22.           /*
    
23.            输出结果： （KEY自动进行排序）
    
24.             1--->111
    
25.                 2--->222
    
26.                 3--->333
    
27.                 4--->444
    
28.                 5--->555
    
29.           */
    
30.         }
    
31. 
    
32. }
    

复制代码