跳转至

Java Stream 排序：order by 的优雅实现

简介

在 Java 编程中，处理集合数据时常常需要对数据进行排序。Java 8 引入的 Stream API 为集合操作带来了极大的便利，其中排序功能可以通过 sorted() 方法来实现，类似于 SQL 中的 ORDER BY 子句。本文将详细介绍 Java Stream 排序的基础概念、使用方法、常见实践以及最佳实践，帮助读者深入理解并高效使用 Java Stream 的排序功能。

目录

  1. 基础概念
  2. 使用方法
  3. 常见实践
  4. 最佳实践
  5. 小结
  6. 参考资料

基础概念

什么是 Java Stream？

Java Stream 是 Java 8 引入的一个新的抽象概念，它允许以声明式的方式处理集合数据。Stream 不是一个数据结构，而是对数据进行操作的一种方式，它可以进行过滤、映射、排序等多种操作。

sorted() 方法

Java Stream 提供了 sorted() 方法用于对元素进行排序。sorted() 方法有两种重载形式： - sorted()：使用元素的自然顺序进行排序，要求元素实现 Comparable 接口。 - sorted(Comparator<? super T> comparator)：使用指定的比较器进行排序，可以自定义排序规则。

使用方法

自然排序

如果元素实现了 Comparable 接口，可以直接使用 sorted() 方法进行自然排序。以下是一个示例：

import java.util.Arrays;
import java.util.List;

public class NaturalSortExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5);
        List<Integer> sortedNumbers = numbers.stream()
                                             .sorted()
                                             .toList();
        System.out.println(sortedNumbers);
    }
}

在这个示例中，Integer 类实现了 Comparable 接口，因此可以直接使用 sorted() 方法对列表中的元素进行自然排序。

自定义排序

如果需要自定义排序规则，可以使用 sorted(Comparator<? super T> comparator) 方法。以下是一个按字符串长度排序的示例：

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class CustomSortExample {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "cherry", "date");
        List<String> sortedWords = words.stream()
                                        .sorted(Comparator.comparingInt(String::length))
                                        .toList();
        System.out.println(sortedWords);
    }
}

在这个示例中，使用 Comparator.comparingInt(String::length) 作为比较器，按照字符串的长度对列表中的元素进行排序。

降序排序

要进行降序排序，可以使用 Comparator.reverseOrder() 或 Comparator.comparing().reversed() 方法。以下是一个降序排序的示例：

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class DescendingSortExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5);
        List<Integer> sortedNumbers = numbers.stream()
                                             .sorted(Comparator.reverseOrder())
                                             .toList();
        System.out.println(sortedNumbers);
    }
}

在这个示例中，使用 Comparator.reverseOrder() 方法对列表中的元素进行降序排序。

常见实践

对对象列表排序

在实际开发中，经常需要对对象列表进行排序。以下是一个对 Person 对象按年龄排序的示例：

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

public class ObjectListSortExample {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
                new Person("Alice", 25),
                new Person("Bob", 20),
                new Person("Charlie", 30)
        );
        List<Person> sortedPeople = people.stream()
                                          .sorted(Comparator.comparingInt(Person::getAge))
                                          .toList();
        System.out.println(sortedPeople);
    }
}

在这个示例中，使用 Comparator.comparingInt(Person::getAge) 方法对 Person 对象列表按年龄进行排序。

多级排序

有时候需要进行多级排序，例如先按年龄排序，年龄相同时再按姓名排序。以下是一个多级排序的示例：

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

public class MultiLevelSortExample {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
                new Person("Alice", 25),
                new Person("Bob", 20),
                new Person("Alice", 20)
        );
        List<Person> sortedPeople = people.stream()
                                          .sorted(Comparator.comparingInt(Person::getAge)
                                                            .thenComparing(Person::getName))
                                          .toList();
        System.out.println(sortedPeople);
    }
}

在这个示例中，使用 thenComparing() 方法进行多级排序，先按年龄排序，年龄相同时再按姓名排序。

最佳实践

避免不必要的排序

在进行排序操作之前，需要确保排序是必要的。排序操作通常会带来一定的性能开销，因此在数据量较大时，应尽量避免不必要的排序。

使用并行流进行排序

如果数据量较大，可以考虑使用并行流进行排序，以提高性能。以下是一个使用并行流进行排序的示例：

import java.util.Arrays;
import java.util.List;

public class ParallelSortExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5);
        List<Integer> sortedNumbers = numbers.parallelStream()
                                             .sorted()
                                             .toList();
        System.out.println(sortedNumbers);
    }
}

在这个示例中，使用 parallelStream() 方法创建并行流，然后进行排序操作。

使用 Comparator 静态方法

Comparator 类提供了许多静态方法，如 comparing()、comparingInt()、comparingDouble() 等，可以方便地创建比较器。使用这些静态方法可以使代码更加简洁和易读。

小结

Java Stream 的排序功能为集合数据的排序提供了一种简洁、灵活的方式。通过 sorted() 方法，可以使用自然排序或自定义排序规则对元素进行排序。在实际开发中，需要根据具体需求选择合适的排序方式，并遵循最佳实践，以提高代码的性能和可维护性。

参考资料