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]]
}

演示完毕