HashMap不能排序那就只能用TreeMap排序了

TreeMap 的排序

今天在公司遇到這樣的需求了，前端人員想要讓我對HashMap中的數據進行降序排序，我們是展示車輛信息的功能，排序要求是按照年份，

也就是說按照年份降序排序，這裏總結一下

排序思路

TreeMap本身就是有序的集合，但是它的有序默認是升序，也就是 1 2 3 4 5 6這樣，而我們預期的結果是 6 5 4 3 2 1 所以需要對 它進行二次處理，

如何對TreeMap進行排序處理呢？

TreeMap只支持對鍵進行排序，比較，那麼我們來創建TreeMap寫比較

TreeMap<String, List<Car>> tree = new TreeMap<String, List<Car>>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //本來參數順序是按照 2016<2018<2019<2020
                int fist = Integer.parseInt(o1);//key[array]   
                int last = Integer.parseInt(o2);//key[array+1] 
                //
                if (fist < last) {
                    //1) 如果要按照升序排序，則o1 小於o2，返回-1（負數），相等返回0，01大於02返回1（正數） 
　　　　　　　　　　　　return -1;
                } else if (fist     > last) {
                    return 1;
                } else {
                    return 0;
                }
            }
        });

 這裏我對  compare()裏面比較的邏輯是這樣理解的，

如果要按照升序排序，

則o1 小於o2，返回-1（負數），

相等返回0，

01大於02返回1（正數） 　　

如果要按照降序排序，

則o1 小於o2，返回1（正數），

相等返回0，

01大於02返回-1（負數） 　

給TreeMap賦值

我們先創建一些數據放入HashMap中，因爲這是我們最初衷的需求，就是在遇到HashMap不能排序的時候，選擇TreeMap來排序

HashMap<String,List<Car>> hashmap=new HashMap<String,List<Car>>();
        List<Car> list = new ArrayList<>();
        list.add(new Car("奔馳", 18, 2019));
        list.add(new Car("寶馬", 18, 2014));
        List<Car> list1 = new ArrayList<>();
        list1.add(new Car("瑪莎拉蒂", 18, 2020));
        list1.add(new Car("邁巴赫", 18, 2018));
        List<Car> list2 = new ArrayList<>();
        list2.add(new Car("本田", 18, 2020));
        list2.add(new Car("豐田", 18, 2018));
        List<Car> list3 = new ArrayList<>();
        list3.add(new Car("Jeep", 18, 2020));
        list3.add(new Car("越野", 18, 2018));
        hashmap.put("2019", list);
        hashmap.put("2016", list1);
        hashmap.put("2020", list2);
        hashmap.put("2018", list3);

接下來我們把HashMap中的數據一次性放入TreeMap中，當前TreeMap提供了這個方法

tree.putAll(hashmap);

接下來我們遍歷一下

Iterator iter = tree.entrySet().iterator();
        System.out.println("默認升序{");
        while (iter.hasNext()) {
            Map.Entry entry = (Map.Entry) iter.next();

            System.out.println("key=" + entry.getKey() + "\t value=" + entry.getValue().toString());
        }
        System.out.print("}");        

打印結果如下

默認升序{
key=2016     value=[Car [name=瑪莎拉蒂, age=18, year=2020], Car [name=邁巴赫, age=18, year=2018]]
key=2018     value=[Car [name=Jeep, age=18, year=2020], Car [name=越野, age=18, year=2018]]
key=2019     value=[Car [name=奔馳, age=18, year=2019], Car [name=寶馬, age=18, year=2014]]
key=2020     value=[Car [name=本田, age=18, year=2020], Car [name=豐田, age=18, year=2018]]
}

下面我們修改一下排序時比較的返回值來測試一下降序效果，修改的代碼如下

TreeMap<String, List<Car>> tree = new TreeMap<String, List<Car>>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //本來參數順序是按照 2016<2018<2019<2020
                int fist = Integer.parseInt(o1);//key[array]   
                int last = Integer.parseInt(o2);//key[array+1] 
                //3 < 4   降序效果的
                if (fist < last) {
                    //1) 如果要按照升序排序，則o1 小於o2，返回-1（負數），相等返回0，01大於02返回1（正數） 
                    return 1;
                } else if (fist > last) {
                    return -1;
                } else {
                    return 0;
                }
            }
        });

打印結果：

降序如下{
key=2020     value=[Car [name=本田, age=18, year=2020], Car [name=豐田, age=18, year=2018]]
key=2019     value=[Car [name=奔馳, age=18, year=2019], Car [name=寶馬, age=18, year=2014]]
key=2018     value=[Car [name=Jeep, age=18, year=2020], Car [name=越野, age=18, year=2018]]
key=2016     value=[Car [name=瑪莎拉蒂, age=18, year=2020], Car [name=邁巴赫, age=18, year=2018]]
}

演示完畢