集合（list、set、map）的简单升序降序实现

这篇博客主要总结一下平时比较常用的几种集合排序（升序降序）方法。

1.List排序

1）基本数据类型的包装类集合排序

import com.xxxx.domain.Emp;
import org.junit.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.*;

/**
 * @desc 集合排序
 * @author gc
 * @date 2021/5/25 
 */
@SpringBootTest
public class CollectionSortTest {

    /**
     * 基本类型包装类list排序
     */
    @Test
    public void sortList1(){
        List<Integer> lists = new ArrayList<>(3);
        lists.add(5);
        lists.add(1);
        lists.add(10);
        //方法1：使用Collections进行排序：
        //升序
        Collections.sort(lists);
        //降序
        Collections.sort(lists,Comparator.reverseOrder());
        //方法2：使用Java8 Stream进行排序：
        //升序
        lists = lists.stream().sorted().collect(Collectors.toList());
        //降序
        lists = lists.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
        for (Integer ele : lists) {
            System.out.println(ele);
        }
    }

}

2）自定义实体类集合排序：

    /**
     * 实体类list排序
     */
    @Test
    public void sortList2(){
        List<Emp> lists = new ArrayList<>(3);
        lists.add(new Emp(3, "员工1"));
        lists.add(new Emp(1, "员工2"));
        lists.add(new Emp(2, "员工3"));
        //方法1：借助Collections排序
        //升序
        Collections.sort(lists, Comparator.comparing(Emp::getAge));
        //降序
        Collections.sort(lists, Comparator.comparing(Emp::getAge).reversed());
        //方法2：借助Java8 Stream排序：
        //升序
        lists = lists.stream().sorted(Comparator.comparing(Emp::getAge)).collect(Collectors.toList());
        //降序
        lists = lists.stream().sorted(Comparator.comparing(Emp::getAge).reversed()).collect(Collectors.toList());
        for (Emp ele : lists) {
            System.out.println(ele);
        }
    }

2.Map排序

1）单纯根据key排序(用TreeMap实现)：

    @Test
    public void sortMap1(){
        //默认升序
        Map<String, String> map = new TreeMap<>(String::compareTo);
        //降序
        //Map<String, String> map = new TreeMap<>(Comparator.reverseOrder());
        map.put("a","2");
        map.put("c","5");
        map.put("d","6");
        map.put("b","1");
        map.forEach((k,v)->{
            System.out.println(k+":"+v);
        });
    }

2）根据key或value排序：

    @Test
    public void sortMap2(){
        Map map = new HashMap<>();
        map.put(5, 2);
        map.put(2, 5);
        map.put(9,1);
        List<Map.Entry<Integer, Integer>> mapList = new ArrayList<>(map.entrySet());
        //根据key默认升序
        Collections.sort(mapList, Comparator.comparing(Map.Entry::getKey));
        //根据key降序
        Collections.sort(mapList, (o1, o2) -> o2.getKey().compareTo(o1.getKey()));
        //根据value默认升序
        Collections.sort(mapList, Comparator.comparing(Map.Entry::getValue));
        //根据value降序
        Collections.sort(mapList, (o1, o2) -> o2.getValue().compareTo(o1.getValue()));
        mapList.forEach(o -> System.out.println(o.getKey() + ":" + o.getValue()));
        //如果一定要返回一个map，就new一个LinkedHashMap，将list中所有值依次put进去就可以
        /*LinkedHashMap<String,String> linkedHashMap = new LinkedHashMap<>();
        mapList.forEach(o -> {
            linkedHashMap.put(o.getKey(), o.getValue());
        });*/
    }

3.Set排序

网上Set排序的例子很多，不过大部分排序方法是大同小异的，通常最后排序都是依据TreeSet进行排序：

1.基本类型包装类集合的Set排序：

    @Test
    public void sortSet1(){
        //方法1：使用TreeSet排序
        //升序
        TreeSet<Long> sets = new TreeSet<>();
        //降序
        TreeSet<Long> reverseSets = new TreeSet<>(Comparator.reverseOrder());
        sets.add(5L);
        sets.add(2L);
        sets.add(19L);
        //方法2：使用Java8 Stream排序（Set转为List）：
        //这种排序法的set类型可以是TreeSet，也可以是HashSet
        //升序
        List<Long> collect = sets.stream().sorted().collect(Collectors.toList());
        //降序
        List<Long> reverseCollect = sets.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
    }

2.自定义实体类排序：

    /**
    * 按照实体类某些属性排序
    */
    @Test
    public void sortSet2(){
        //方法1：使用TreeSet排序
        //升序
        TreeSet<Emp> sets = new TreeSet<>(Comparator.comparing(Emp::getAge));
        sets.add(new Emp(5, "员工1"));
        sets.add(new Emp(12, "员工2"));
        sets.add(new Emp(9, "员工3"));
        //降序
        TreeSet<Emp> reverseSets = new TreeSet<>(Comparator.comparing(Emp::getAge).reversed());
        //方法2：使用Java8 Stream排序（转为list）：
        //这种排序法的set类型可以是TreeSet，也可以是HashSet
        //升序
        List<Emp> collect = sets.stream().sorted(Comparator.comparing(Emp::getAge)).collect(Collectors.toList());
        //降序
        List<Emp> reverseCollect = sets.stream().sorted(Comparator.comparing(Emp::getAge).reversed()).collect(Collectors.toList());
    }

附上Emp类：

package com.xxxx.domain;

import lombok.Data;

/**
 * @desc 员工实体类
 * @author gc
 * @date 2021/5/25 
 */
@Data
public class Emp {
    public Emp(Integer age, String name) {
        this.age = age;
        this.name = name;
    }

    private Integer age;
    private String name;
}

参照的博客：

如何对map进行排序_顽石九变的博客-CSDN博客_map 排序