集合list排序

集合list排序
1、list<基本类型>

基础数据

List<Integer> list = Arrays.asList(1, 5, 6, 2, 4, 80, 43, 7);

1.1 Collections.sort排序

Collections.sort(list);
System.out.println("Collections.sort正序----->"+list);
Collections.reverse(list);
System.out.println("Collections.reverse倒序-->"+list);

结果:

Collections.sort正序----->[1, 2, 4, 5, 6, 7, 43, 80]
Collections.reverse倒序-->[80, 43, 7, 6, 5, 4, 2, 1]

1.2 list.sort排序

list.sort(Integer::compareTo);
System.out.println("list.sort正序-->"+list);
list.sort(Comparator.reverseOrder());
System.out.println("list.sort倒序-->"+list);

结果:

list.sort正序-->[1, 2, 4, 5, 6, 7, 43, 80]
list.sort倒序-->[80, 43, 7, 6, 5, 4, 2, 1]

1.3 list.stream()排序

List<Integer> collect = list.stream().sorted().collect(Collectors.toList());
System.out.println("stream.sorted正序-->" + collect);
List<Integer> collect1 = list.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
System.out.println("stream.sorted倒序-->" + collect1);

结果:

stream.sorted正序-->[1, 2, 4, 5, 6, 7, 43, 80]
stream.sorted倒序-->[80, 43, 7, 6, 5, 4, 2, 1]

2、list<对象>
List<类> list = new ArrayList<>();

基础数据

List<PersonDto> personDtos = ListUtil.toList(
        new PersonDto(1, "张三", 174, 32),
        new PersonDto(4, "李四", 173, 23),
        new PersonDto(4, "赵六", 185, 20),
        new PersonDto(3, "王五", 192, 20),
        new PersonDto(5, "孙七", 169, 26)
);

2.1 单属性排序（升序）

list.stream().sorted(Comparator.comparing(类::属性一));

System.out.println("1.默认排序");
personDtos.forEach(System.out::println);
System.out.println("2.按年龄升序");
personDtos.stream().sorted(Comparator.comparing(PersonDto::getAge)).forEach(System.out::println);
 
结果:
1.默认排序
PersonDto{id=1, name='张三', tall=174, age=32}
PersonDto{id=4, name='李四', tall=173, age=23}
PersonDto{id=4, name='赵六', tall=185, age=20}
PersonDto{id=3, name='王五', tall=192, age=20}
PersonDto{id=5, name='孙七', tall=169, age=26}
2.按年龄升序
PersonDto{id=4, name='赵六', tall=185, age=20}
PersonDto{id=3, name='王五', tall=192, age=20}
PersonDto{id=4, name='李四', tall=173, age=23}
PersonDto{id=5, name='孙七', tall=169, age=26}
PersonDto{id=1, name='张三', tall=174, age=32

2.2 单属性排序（降序）

list.stream().sorted(Comparator.comparing(类::属性一).reversed());
//先以属性一升序,而后对结果集进行属性一降序

list.stream().sorted(Comparator.comparing(类::属性一,
Comparator.reverseOrder())); //以属性一降序

 
System.out.println("3.1 按年龄倒序 (先以年龄升序,而后对结果集进行年龄降序)");
personDtos.stream().sorted(Comparator.comparing(PersonDto::getAge).reversed()).forEach(System.out::println);
System.out.println("3.2 按年龄倒序 (先以年龄升降序)");
personDtos.stream().sorted(Comparator.comparing(PersonDto::getAge,Comparator.reverseOrder())).forEach(System.out::println);
 
结果:
3.1 按年龄倒序 (先以年龄升序,而后对结果集进行年龄降序)
PersonDto{id=1, name='张三', tall=174, age=32}
PersonDto{id=5, name='孙七', tall=169, age=26}
PersonDto{id=4, name='李四', tall=173, age=23}
PersonDto{id=4, name='赵六', tall=185, age=20}
PersonDto{id=3, name='王五', tall=192, age=20}
3.2 按年龄倒序 (先以年龄升降序)
PersonDto{id=1, name='张三', tall=174, age=32}
PersonDto{id=5, name='孙七', tall=169, age=26}
PersonDto{id=4, name='李四', tall=173, age=23}
PersonDto{id=4, name='赵六', tall=185, age=20}
PersonDto{id=3, name='王五', tall=192, age=20}

2.3 多属性排序（属性一升序，属性二升序）

list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二));//以类属性一升序
属性二升序

 
System.out.println("4.按学号升序、年龄升序");
personDtos
      .stream()
      .sorted(Comparator.comparingInt(PersonDto::getId)
            .thenComparingInt(PersonDto::getAge))
      .collect(Collectors.toList())
      .forEach(System.out::println);
 
结果:
4.按学号升序、年龄升序
PersonDto{id=1, name='张三', tall=174, age=32}
PersonDto{id=3, name='王五', tall=192, age=20}
PersonDto{id=4, name='赵六', tall=185, age=20}
PersonDto{id=4, name='李四', tall=173, age=23}
PersonDto{id=5, name='孙七', tall=169, age=26}

2.4 多属性排序（属性一降序，属性二降序）

list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,升序结果进行属性一降序,再进行属性二降序

list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二).reversed());//先以属性一升序,进行属性二升序,再进行结果降序

list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一降序,再进行属性二降序

 
System.out.println("5.1.按学号降序、年龄降序 (先以年龄升序,升序结果进行学号降序,再进行年龄降序)");
personDtos
      .stream()
      .sorted(Comparator.comparing(PersonDto::getId)
            .reversed()
            .thenComparing(PersonDto::getAge,Comparator.reverseOrder()))
      .collect(Collectors.toList())
      .forEach(System.out::println);
 
System.out.println("5.2.按学号降序、年龄降序 (先以年龄升序,再进行年龄升序,结果进行(学号&年龄)降序)");
personDtos
      .stream()
      .sorted(Comparator.comparingInt(PersonDto::getId)
            .thenComparingInt(PersonDto::getAge)
            .reversed())
      .collect(Collectors.toList())
      .forEach(System.out::println);
 
System.out.println("5.3.按学号降序、年龄降序 (先以学号降序,再进行年龄降序)");
personDtos
      .stream()
      .sorted(Comparator.comparing(PersonDto::getId,Comparator.reverseOrder())
            .thenComparing(PersonDto::getAge,Comparator.reverseOrder()))
      .collect(Collectors.toList())
      .forEach(System.out::println);
 
结果:
5.1.按学号降序、年龄降序 (先以年龄升序,升序结果进行学号降序,再进行年龄降序)
PersonDto{id=5, name='孙七', tall=169, age=26}
PersonDto{id=4, name='李四', tall=173, age=23}
PersonDto{id=4, name='赵六', tall=185, age=20}
PersonDto{id=3, name='王五', tall=192, age=20}
PersonDto{id=1, name='张三', tall=174, age=32}
5.2.按学号降序、年龄降序 (先以年龄升序,再进行年龄升序,结果进行(学号&年龄)降序)
PersonDto{id=5, name='孙七', tall=169, age=26}
PersonDto{id=4, name='李四', tall=173, age=23}
PersonDto{id=4, name='赵六', tall=185, age=20}
PersonDto{id=3, name='王五', tall=192, age=20}
PersonDto{id=1, name='张三', tall=174, age=32}
5.3.按学号降序、年龄降序 (先以学号降序,再进行年龄降序)
PersonDto{id=5, name='孙七', tall=169, age=26}
PersonDto{id=4, name='李四', tall=173, age=23}
PersonDto{id=4, name='赵六', tall=185, age=20}
PersonDto{id=3, name='王五', tall=192, age=20}
PersonDto{id=1, name='张三', tall=174, age=32}

2.5 多属性排序（属性一升序，属性二降序）

list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二).reversed());//先以属性一升序,升序结果进行属性一降序,再进行属性二升序,结果进行属性一降序属性二降序

list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,再进行属性二降序

 
System.out.println("6.1 按学号升序、年龄降序 (先以学号升序,升序结果进行学号降序,再进行年龄升序,结果进行(学号&年龄)降序)");
personDtos
      .stream()
      .sorted(Comparator.comparing(PersonDto::getId).reversed()
            .thenComparing(PersonDto::getAge).reversed())
      .collect(Collectors.toList())
      .forEach(System.out::println);
 
System.out.println("6.2 按学号升序、年龄降序 (先以学号升序,再进行年龄降序)");
personDtos
      .stream()
      .sorted(Comparator.comparing(PersonDto::getId)
            .thenComparing(PersonDto::getAge,Comparator.reverseOrder()))
      .collect(Collectors.toList())
      .forEach(System.out::println);
 
结果:
6.1 按学号升序、年龄降序 (先以学号升序,升序结果进行学号降序,再进行年龄升序,结果进行(学号&年龄)降序)
PersonDto{id=1, name='张三', tall=174, age=32}
PersonDto{id=3, name='王五', tall=192, age=20}
PersonDto{id=4, name='李四', tall=173, age=23}
PersonDto{id=4, name='赵六', tall=185, age=20}
PersonDto{id=5, name='孙七', tall=169, age=26}
6.2 按学号升序、年龄降序 (先以学号升序,再进行年龄降序)
PersonDto{id=1, name='张三', tall=174, age=32}
PersonDto{id=3, name='王五', tall=192, age=20}
PersonDto{id=4, name='李四', tall=173, age=23}
PersonDto{id=4, name='赵六', tall=185, age=20}
PersonDto{id=5, name='孙七', tall=169, age=26}

2.6 多属性排序（属性一降序，属性二升序）

list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二));//先以属性一升序,升序结果进行属性一降序,再进行属性二升序

list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二));//先以属性一降序,再进行属性二升序

 
System.out.println("7.1 按学号降序、年龄升序 (先以学号升序,升序结果进行学号降序,再进行年龄升序)");
personDtos
      .stream()
      .sorted(Comparator.comparing(PersonDto::getId)
            .reversed()
            .thenComparing(Comparator.comparing(PersonDto::getAge)))
      .collect(Collectors.toList())
      .forEach(System.out::println);
 
System.out.println("7.2 按学号降序、年龄升序 (以学号学号降序,再进行年龄升序)");
personDtos
      .stream()
      .sorted(Comparator.comparing(PersonDto::getId,Comparator.reverseOrder())
            .thenComparing(Comparator.comparing(PersonDto::getAge))
            .thenComparing(Comparator.comparing(PersonDto::getTall)))
      .collect(Collectors.toList())
      .forEach(System.out::println);
结果:
7.1 按学号降序、年龄升序 (先以学号升序,升序结果进行学号降序,再进行年龄升序)
PersonDto{id=5, name='孙七', tall=169, age=26}
PersonDto{id=4, name='赵六', tall=185, age=20}
PersonDto{id=4, name='李四', tall=173, age=23}
PersonDto{id=3, name='王五', tall=192, age=20}
PersonDto{id=1, name='张三', tall=174, age=32}
7.2 按学号降序、年龄升序 (以学号学号降序,再进行年龄升序)
PersonDto{id=5, name='孙七', tall=169, age=26}
PersonDto{id=4, name='赵六', tall=185, age=20}
PersonDto{id=4, name='李四', tall=173, age=23}
PersonDto{id=3, name='王五', tall=192, age=20}
PersonDto{id=1, name='张三', tall=174, age=32}

3、重点关注（倒序的两种写法）
！！！两种排序完全不同：1是获得排序结果后再排序，2是直接进行排序！！！

1, Comparator.comparing(类::属性一).reversed();
2,Comparator.comparing(类::属性一,Comparator.reverseOrder());