Java 中的 Stream Sorted：深入解析与实践

简介

在 Java 8 引入的 Stream API 为处理集合数据提供了一种全新且强大的方式。其中，sorted 方法是 Stream API 中用于对元素进行排序的重要操作。通过 sorted，我们可以以一种声明式的风格对集合元素进行排序，而无需编写繁琐的循环和复杂的排序逻辑。本文将详细介绍 stream sorted 在 Java 中的基础概念、使用方法、常见实践以及最佳实践，帮助读者更好地掌握这一强大的特性。

基础概念

Stream 是 Java 8 中引入的一个接口，它代表了一组支持顺序和并行聚合操作的元素序列。sorted 方法是 Stream 接口的中间操作，它会返回一个由该流的元素组成的新流，并且这些元素是经过排序的。

排序的依据可以是自然顺序（如果元素实现了 Comparable 接口），也可以是通过自定义的 Comparator 来定义。

使用方法

自然排序

如果流中的元素类型实现了 Comparable 接口，那么可以直接使用 sorted 方法进行自然排序。例如，对于 Integer 类型的集合：

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

public class StreamSortedExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 9);
        numbers.stream()
              .sorted()
              .forEach(System.out::println);
    }
}

在上述代码中，numbers.stream() 创建了一个流，然后调用 sorted() 方法对元素进行自然排序，最后通过 forEach 方法打印出排序后的元素。输出结果为：

自定义排序

如果需要按照自定义的规则进行排序，可以使用带 Comparator 参数的 sorted 方法。例如，对字符串列表按照长度进行排序：

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("banana", "apple", "cherry", "date");
        words.stream()
              .sorted(Comparator.comparingInt(String::length))
              .forEach(System.out::println);
    }
}

在这个例子中，Comparator.comparingInt(String::length) 创建了一个根据字符串长度进行比较的 Comparator。输出结果为：

date
apple
cherry
banana

常见实践

对基本类型集合排序

对于 int、double、long 等基本类型的集合，使用 stream sorted 非常简单。例如对 int 数组排序：

import java.util.Arrays;

public class PrimitiveSortExample {
    public static void main(String[] args) {
        int[] numbers = {5, 2, 8, 1, 9};
        Arrays.stream(numbers)
              .sorted()
              .forEach(System.out::println);
    }
}

对对象集合排序

假设我们有一个自定义类 Person，并希望对 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 ObjectSortExample {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
                new Person("Alice", 25),
                new Person("Bob", 20),
                new Person("Charlie", 30)
        );
        people.stream()
              .sorted(Comparator.comparingInt(Person::getAge))
              .forEach(System.out::println);
    }
}

输出结果为：

Person{name='Bob', age=20}
Person{name='Alice', age=25}
Person{name='Charlie', age=30}

最佳实践

性能优化

在处理大规模数据时，并行流可以显著提高排序性能。例如：

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

public class ParallelSortExample {
    public static void main(String[] args) {
        List<Integer> largeNumbers = Arrays.asList();
        // 填充大量数据
        for (int i = 0; i < 1000000; i++) {
            largeNumbers.add((int) (Math.random() * 1000000));
        }
        long startTime = System.currentTimeMillis();
        largeNumbers.parallelStream()
                    .sorted()
                    .forEach(e -> {});
        long endTime = System.currentTimeMillis();
        System.out.println("Parallel sort time: " + (endTime - startTime) + " ms");

        startTime = System.currentTimeMillis();
        largeNumbers.stream()
                    .sorted()
                    .forEach(e -> {});
        endTime = System.currentTimeMillis();
        System.out.println("Sequential sort time: " + (endTime - startTime) + " ms");
    }
}

通过比较并行流和顺序流的排序时间，可以发现并行流在处理大数据量时具有更好的性能。

代码可读性优化

使用方法引用和静态导入可以提高代码的可读性。例如：

import static java.util.Comparator.comparingInt;

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

class Product {
    private String name;
    private int price;

    public Product(String name, int price) {
        this.name = name;
        this.price = price;
    }

    public int getPrice() {
        return price;
    }

    @Override
    public String toString() {
        return "Product{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

public class ReadabilityExample {
    public static void main(String[] args) {
        List<Product> products = Arrays.asList(
                new Product("Book", 25),
                new Product("Pen", 5),
                new Product("Laptop", 1000)
        );
        products.stream()
              .sorted(comparingInt(Product::getPrice))
              .forEach(System.out::println);
    }
}

小结

通过本文的介绍，我们深入了解了 Java 中 stream sorted 的基础概念、使用方法、常见实践以及最佳实践。stream sorted 为我们提供了一种简洁、高效且可读的方式来对集合元素进行排序。无论是自然排序还是自定义排序，都可以通过简单的方法调用实现。在实际应用中，合理使用并行流和优化代码结构可以进一步提升性能和代码可读性。