java8stream如何升序与降序

Java 8 Stream进行升序与降序排序的方法有：使用sorted()方法、通过传递自定义的Comparator进行控制、处理复杂类型时结合Comparator和Comparator.reversed()使用。下面我们详细讨论一下其中的一点——传递自定义的Comparator进行控制。

在Java 8中，Stream API 提供了强大的数据处理功能，其中包括对数据进行排序。sorted()方法可以直接用于排序，但如果需要自定义排序逻辑，比如按对象的某个属性进行排序，则需要传递一个自定义的Comparator。例如，对于一个Person类，我们可以根据age属性进行升序和降序排序。

List<Person> people = Arrays.asList(new Person("John", 30), new Person("Jane", 25), new Person("Tom", 35));

// 升序排序
List<Person> sortedAsc = people.stream()
    .sorted(Comparator.comparingInt(Person::getAge))
    .collect(Collectors.toList());
// 降序排序
List<Person> sortedDesc = people.stream()
    .sorted(Comparator.comparingInt(Person::getAge).reversed())
    .collect(Collectors.toList());

一、使用sorted()方法

在Java 8中，Stream API提供了sorted()方法，可以对流中的元素进行自然顺序排序（升序）或使用自定义的Comparator进行排序。sorted()方法有两种形式：

• Stream<T> sorted()：对元素进行自然顺序排序。
• Stream<T> sorted(Comparator<? super T> comparator)：使用指定的Comparator进行排序。

自然顺序排序

对于具有自然顺序的类型（如数字、字符串），可以直接使用sorted()方法进行升序排序。

List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9);

List<Integer> sortedNumbers = numbers.stream()
    .sorted()
    .collect(Collectors.toList());

自定义排序

对于自定义类型，可以传递一个Comparator对象来定义排序规则。

List<Person> people = Arrays.asList(new Person("John", 30), new Person("Jane", 25), new Person("Tom", 35));

List<Person> sortedByAge = people.stream()
    .sorted(Comparator.comparingInt(Person::getAge))
    .collect(Collectors.toList());

二、通过传递自定义的Comparator进行控制

当需要根据对象的多个属性进行排序时，可以使用多个Comparator进行组合。Comparator接口提供了多种方法来创建和组合比较器。

升序排序

对于升序排序，可以直接使用Comparator.comparing()方法。

List<Person> sortedByName = people.stream()

    .sorted(Comparator.comparing(Person::getName))
    .collect(Collectors.toList());

降序排序

对于降序排序，可以使用Comparator.reversed()方法。

List<Person> sortedByNameDesc = people.stream()

    .sorted(Comparator.comparing(Person::getName).reversed())
    .collect(Collectors.toList());

多重排序

如果需要先按一个属性排序，再按另一个属性排序，可以使用Comparator.thenComparing()方法。

List<Person> sortedByAgeThenName = people.stream()

    .sorted(Comparator.comparingInt(Person::getAge).thenComparing(Person::getName))
    .collect(Collectors.toList());

三、处理复杂类型时结合Comparator和Comparator.reversed()使用

对于复杂类型的数据排序，Comparator提供了多种链式调用的方法，使得排序逻辑更加灵活和强大。

按多个字段排序

假设我们有一个包含多个字段的对象，并且需要按多个字段进行排序。

List<Employee> employees = Arrays.asList(

    new Employee("John", "Doe", 30),
    new Employee("Jane", "Doe", 25),
    new Employee("John", "Smith", 35)
);
List<Employee> sortedEmployees = employees.stream()
    .sorted(Comparator.comparing(Employee::getLastName)
    .thenComparing(Employee::getFirstName)
    .thenComparingInt(Employee::getAge))
    .collect(Collectors.toList());

按字段降序排序

如果需要按某个字段降序排序，可以在相应的Comparator后面使用reversed()方法。

List<Employee> sortedEmployeesDesc = employees.stream()

    .sorted(Comparator.comparing(Employee::getLastName)
    .thenComparing(Employee::getFirstName)
    .thenComparingInt(Employee::getAge).reversed())
    .collect(Collectors.toList());

四、使用Comparator的静态方法

Comparator接口提供了多个静态方法，可以方便地创建和组合比较器。

使用Comparator.comparing()

Comparator.comparing()方法可以创建一个比较器，并且支持链式调用。

List<Person> sortedByName = people.stream()

    .sorted(Comparator.comparing(Person::getName))
    .collect(Collectors.toList());

使用Comparator.nullsFirst()和Comparator.nullsLast()

在处理可能包含null值的集合时，可以使用Comparator.nullsFirst()和Comparator.nullsLast()方法。

List<Person> peopleWithNulls = Arrays.asList(new Person("John", 30), null, new Person("Jane", 25));

List<Person> sortedWithNullsFirst = peopleWithNulls.stream()
    .sorted(Comparator.nullsFirst(Comparator.comparing(Person::getName)))
    .collect(Collectors.toList());

五、结合Stream的其他操作

在实际应用中，排序通常是数据处理的一部分，可以结合Stream的其他操作，如过滤、映射、收集等。

排序和过滤

可以在排序之前或之后对数据进行过滤。

List<Person> filteredAndSorted = people.stream()

    .filter(person -> person.getAge() > 20)
    .sorted(Comparator.comparingInt(Person::getAge))
    .collect(Collectors.toList());

排序和映射

可以在排序之前或之后对数据进行映射。

List<String> sortedNames = people.stream()

    .sorted(Comparator.comparing(Person::getName))
    .map(Person::getName)
    .collect(Collectors.toList());

六、总结

Java 8 Stream API 提供了丰富的排序功能，可以通过sorted()方法实现自然顺序和自定义顺序的排序。通过传递自定义的Comparator，可以灵活地控制排序逻辑，并结合Comparator.reversed()方法实现降序排序。在处理复杂类型的数据时，可以结合多个Comparator进行多重排序。通过这些方法，可以轻松实现对数据的升序与降序排序，使得代码更加简洁和易读。

相关问答FAQs：

1. Java 8 Stream中如何对元素进行升序排列？

要对Java 8 Stream中的元素进行升序排列，可以使用Stream的sorted()方法。sorted()方法可以接收一个Comparator参数，用于指定排序的方式。例如，对一个包含整数的Stream进行升序排列，可以使用以下代码：

List<Integer> numbers = Arrays.asList(5, 3, 8, 2, 9);
List<Integer> sortedNumbers = numbers.stream()
                                     .sorted(Comparator.naturalOrder())
                                     .collect(Collectors.toList());

2. 如何对Java 8 Stream中的元素进行降序排列？

要对Java 8 Stream中的元素进行降序排列，可以使用sorted()方法的另一个重载方法，该方法接收一个Comparator参数，并使用Comparator的reversed()方法来实现降序排序。例如，对一个包含字符串的Stream进行降序排列，可以使用以下代码：

List<String> words = Arrays.asList("apple", "banana", "cherry", "date");
List<String> sortedWords = words.stream()
                               .sorted(Comparator.reverseOrder())
                               .collect(Collectors.toList());

3. 如何在Java 8 Stream中同时进行升序和降序排列？

在Java 8 Stream中，可以通过使用sorted()方法的多个重载方法来同时进行升序和降序排列。例如，如果要先按字符串长度进行升序排列，然后再按字母顺序进行降序排列，可以使用以下代码：

List<String> words = Arrays.asList("apple", "banana", "cherry", "date");
List<String> sortedWords = words.stream()
                               .sorted(Comparator.comparing(String::length)
                                               .thenComparing(Comparator.reverseOrder()))
                               .collect(Collectors.toList());

在上述代码中，首先使用Comparator.comparing()方法按字符串长度进行升序排列，然后使用thenComparing()方法按字母顺序进行降序排列。