常用List集合排序总结

常用List集合排序总结

一、创建两个测试对象

创建两个常用的排序对象

//对象一
@Data
public class Org {

    private String name;

    private Integer age;

    public Org(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
}
//对象二
@Data
public class Org2 {

    private String name;

    private Integer age;

    private Integer fraction;

    public Org2(String name, Integer age, Integer fraction) {
        this.name = name;
        this.age = age;
        this.fraction = fraction;
    }
}

二、测试对象

//对象一
        List<Org> orgList = new ArrayList<>();
        orgList.add(new Org("zhangsan1",6));
        orgList.add(new Org("zhangsan2",15));
        orgList.add(new Org("zhangsan3",14));
        orgList.add(new Org("zhangsan4",22));
        orgList.add(new Org("zhangsan5",2));
        orgList.add(new Org("zhangsan6",18));
        orgList.add(new Org("zhangsan7",56));

//对象二
        List<Org2> org2List = new ArrayList<>();
        org2List.add(new Org2("zhangsan1",6,55));
        org2List.add(new Org2("zhangsan2",6,66));
        org2List.add(new Org2("zhangsan3",16,96));
        org2List.add(new Org2("zhangsan4",5,12));
        org2List.add(new Org2("zhangsan5",22,23));
        org2List.add(new Org2("zhangsan6",22,44));
        org2List.add(new Org2("zhangsan7",35,78));

//单属性集合
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(16);
        list.add(12);
        list.add(13);
        list.add(11);
        list.add(19);

三、排序方法

1、Collections的排序

 //单一属性排序，顺序
 Collections.sort(list);
        list.forEach( s ->{
            System.out.println(s);
        });
        
 //单一属性排序，倒序
 Collections.reverse(list);
        list.forEach( s ->{
            System.out.println(s);
        });

2、Comparator的排序

//单一属性的倒序
List<Integer> collect = list.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
        collect.forEach( s ->{
            System.out.println(s);
        });

3、Comparator的排序（对象）

 //根据对象属性顺序
orgList.sort(Comparator.comparing(Org::getAge));
        orgList.forEach( s -> {
            System.out.println(s.toString() + "->"+s.getAge());
        });
        
 //根据对象属性倒序
 orgList.sort((m1, m2) -> m2.getAge().compareTo(m1.getAge()));
        orgList.forEach( s -> {
            System.out.println(s.toString() + "->"+s.getAge());
        });
        
//对象属性倒序 - > reversed()方法倒序，去掉顺序
List<Org> collect1 = orgList.stream()
                .sorted(Comparator.comparing(Org::getAge).reversed())
                .collect(Collectors.toList());
        collect1.forEach( s -> {
            System.out.println(s.toString() + "->"+s.getAge());
        });

//多属性排序thenComparing - > reversed()方法倒序，去掉顺序
/*thenComparing可以无限拼接排序规则，先按照前面的排序再按照后面的排序，
如果全部按照统一排序，只需要在最后加上reversed()倒序，或者不加顺序*/
List<Org2> collect2 = org2List.stream()
                .sorted(Comparator.comparing(Org2::getAge).thenComparing(Org2::getFraction).reversed())
                .collect(Collectors.toList());
        collect2.forEach( s -> {
            System.out.println(s.toString() + "->"+s.getAge());
        });

//如果每个排序都要按照特定的方式排序，则需要在每个属性后面加上对应的排序规则，例子前面倒序后面顺序。
List<Org2> collect3 = org2List.stream()
                .sorted(Comparator.comparing(Org2::getAge).reversed().thenComparing(Org2::getFraction))
                .collect(Collectors.toList());
        collect3.forEach( s -> {
            System.out.println(s.toString() + "->"+s.getAge());
        });

//如果每个排序都要按照特定的方式排序，则需要在每个属性后面加上对应的排序规则，例子前面顺序后面倒序。
/*特殊情况：最后一个属性倒序，由于最后一个属性的.reversed()为全部属性的排序规则，
那么前面的属性排序规则就正好相反，就和负负得正情况一样，前面属性的正序就会变成倒序，倒序就会变成正序*/
//下面就是按照前面属性的正序，后面属性的倒序规则排序
List<Org2> collect4 = org2List.stream()
                .sorted(Comparator.comparing(Org2::getAge).reversed().thenComparing(Org2::getFraction).reversed())
                .collect(Collectors.toList());
        collect4.forEach( s -> {
            System.out.println(s.toString() + "->"+s.getAge());
        });

以上方法自测无误。