一、TreeMap

TreeMap 預設排序規則：按照key的字典順序來排序（升序）

當然，也可以自定義排序規則：要實現Comparator介面。

用法簡單，先看下下面的demo

public class SortDemo {

    public static void main(String[] args) {
        System.out.println("---------------- 預設 排序結果-----------------");
        createDefaultSortTreeMap();
        System.out.println("---------------- 自定義 排序結果-----------------");
        createDefinitionSortTreeMap();
    }
    
    
 
public static void createDefaultSortTreeMap() {
        TreeMap<String, String> map = new TreeMap<String, String>();
        
        init(map);
        print(map);
    }
    
    public static void createDefinitionSortTreeMap() {
        
        TreeMap<String, String> map = new TreeMap<String, String>(new
 
 Comparator<String>() {

            @Override
            public int compare(String o1, String o2) {
                    return o2.compareTo(o1);
            }
            
        });
        
        init(map);
        print(map);
    }
    
    public static void init(Map<String, String> map) {
        map.put(
 
"c", "1");
        map.put("a", "1");
        map.put("bb", "1");
        map.put("b", "1");
    }
    
    public static void print(Map<String, String> map) {
        Iterator<Entry<String, String>> it = map.entrySet().iterator();
        while(it.hasNext()) {
            Entry<String, String> entry = it.next();
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
    }

結果：
---------------- 預設 排序結果-----------------
a : 1
b : 1
bb : 1
c : 1
---------------- 自定義 排序結果-----------------
c : 1
bb : 1
b : 1
a : 1

二、擴充套件：字典順序

1、排序規則

 兩個字串 s1, s2比較

（1）、如果s1和s2是父子串關係，則 子串 < 父串

（2）、如果非為父子串關係， 則從第一個非相同字元來比較。

　　　  例子 s1 = "ab", s2 = "ac"    這種情況演算法規則是從第二個字元開始比較，由於'b' < 'c' 所以  "ab" < "ac"

（3）、字元間的比較，是按照字元的位元組碼（ascii）來比較

2、  compareTo 實現機制：對於字串來說，字典排序規則；對於數字來說，直接按照大小排序

下面， 是我在專案中，遇到的一個坑，也不能算坑吧，只能說基礎掌握得不紮實，導致老不斷犯錯。先說下場景，有個需求要對Map排序，當時想當然就用了自定義的TreeMap（new

Comparator ）

key 為 String, value 也會String型別， 然後很不幸的是，我的Key 是 數字 字串 ，如 Map.put("2","1"),Map.put("12","1"),Map.put("13","1")

正常思維排序結果是 "2" < "12" < "13" ，仔細一想，compareTo 底層演算法是 "字典排序"，正確的排序結果 ： "12" < "13" <  "2" 

但是我的需求又是想要"2" < "12" < "13"這種效果，如何實現呢？很簡單，把Key改為Long型別，這樣，就會按照大小來排序。

看下下面的例子，可能比較簡單明瞭！

 1 public class SortDemo2 {
  2     
  3     private final static int SIZE = 30;
  4 
  5     public static void main(String[] args) {
  6         System.out.println("---------------- key 為 Sting 排序結果-----------------");
  7         String s = new String();
  8         createTreeMap(s);
  9         System.out.println("---------------- key 為 Long 排序結果-----------------");
 10         Long l = new Long(0);
 11         createTreeMap(l);
 12     }
 13     
 14     public static void createTreeMap(Object obj) {
 15         
 16         TreeMap<Object, Object> map = new TreeMap<>(new Comparator<Object>() {
 17 
 18             @Override
 19             public int compare(Object o1, Object o2) {
 20                 if(o1 instanceof String && o2 instanceof String) {
 21                     return ((String) o1).compareTo((String) o2);
 22                 } else if(o1 instanceof Long && o2 instanceof Long) {
 23                     return ((Long) o1).compareTo((Long) o2);
 24                 }
 25                 return 0;
 26             }
 27             
 28         });
 29         
 30         for(int i = 1; i<SIZE; i++) {
 31             if(obj instanceof String) {
 32                 map.put(String.valueOf(i), String.valueOf(i));
 33             }
 34             if(obj instanceof Long) {
 35                 map.put(Long.valueOf(i), Long.valueOf(i));
 36             }
 37         }
 38         
 39         print(map);
 40     }
 41     
 42     public static void print(Map<Object, Object> map) {
 43         Iterator<Entry<Object, Object>> it = map.entrySet().iterator();
 44         while(it.hasNext()) {
 45             Entry<Object, Object> entry = it.next();
 46             System.out.println(entry.getKey() + " : " + entry.getValue());
 47         }
 48     }
 49 }
 50 
 51 結果：
 52 
 53 ---------------- key 為 Sting 排序結果-----------------
 54 1 : 1
 55 10 : 10
 56 11 : 11
 57 12 : 12
 58 13 : 13
 59 14 : 14
 60 15 : 15
 61 16 : 16
 62 17 : 17
 63 18 : 18
 64 19 : 19
 65 2 : 2
 66 20 : 20
 67 21 : 21
 68 22 : 22
 69 23 : 23
 70 24 : 24
 71 25 : 25
 72 26 : 26
 73 27 : 27
 74 28 : 28
 75 29 : 29
 76 3 : 3
 77 4 : 4
 78 5 : 5
 79 6 : 6
 80 7 : 7
 81 8 : 8
 82 9 : 9
 83 ---------------- key 為 Long 排序結果-----------------
 84 1 : 1
 85 2 : 2
 86 3 : 3
 87 4 : 4
 88 5 : 5
 89 6 : 6
 90 7 : 7
 91 8 : 8
 92 9 : 9
 93 10 : 10
 94 11 : 11
 95 12 : 12
 96 13 : 13
 97 14 : 14
 98 15 : 15
 99 16 : 16
100 17 : 17
101 18 : 18
102 19 : 19
103 20 : 20
104 21 : 21
105 22 : 22
106 23 : 23
107 24 : 24
108 25 : 25
109 26 : 26
110 27 : 27
111 28 : 28
112 29 : 29