【Java 基础篇】Java Stream 流详解

Java Stream（流）是Java 8引入的一个强大的新特性，用于处理集合数据。它提供了一种更简洁、更灵活的方式来操作数据，可以大大提高代码的可读性和可维护性。本文将详细介绍Java Stream流的概念、用法和一些常见操作。

什么是Stream流？

在开始介绍Java Stream流之前，让我们先了解一下什么是流。流是一系列元素的序列，它可以在一次遍历的过程中逐个处理这些元素。在Java中，流是对数据的抽象，可以操作各种不同类型的数据源，如集合、数组、文件等。

Stream流的主要特点包括：

链式调用：可以通过一系列的方法调用来定义对流的操作，使代码更具可读性。
惰性求值：流上的操作不会立即执行，只有在遇到终端操作时才会触发计算。
函数式编程：流操作使用了函数式编程的思想，可以通过Lambda表达式来定义操作。
并行处理：可以轻松地将流操作并行化，充分利用多核处理器的性能。

创建Stream流

在使用Java Stream流之前，首先需要创建一个流。流可以从各种数据源中创建，包括集合、数组、文件等。

从集合创建流

可以使用集合的stream()方法来创建一个流。例如：

代码语言：javascript复制

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
Stream<String> stream = names.stream();

从数组创建流

可以使用Arrays.stream()方法来从数组中创建一个流。例如：

代码语言：javascript复制

int[] numbers = {1, 2, 3, 4, 5};
IntStream stream = Arrays.stream(numbers);

从文件创建流

可以使用Files.lines()方法来从文件中创建一个流。例如：

代码语言：javascript复制

try (Stream<String> lines = Files.lines(Paths.get("data.txt"), Charset.defaultCharset())) {
    // 处理文件中的每一行数据
    lines.forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}

流的操作

一旦创建了流，就可以对其进行各种操作。流的操作可以分为两类：中间操作和终端操作。

中间操作

中间操作是对流的一系列处理步骤，这些步骤会返回一个新的流，允许链式调用。中间操作通常用于对数据进行过滤、映射、排序等操作。一些常见的中间操作包括：

filter(Predicate<T> predicate)：根据条件过滤元素。
map(Function<T, R> mapper)：将元素映射为新的值。
sorted()：对元素进行排序。
distinct()：去重，去除重复的元素。
limit(long maxSize)：限制流中元素的数量。
skip(long n)：跳过流中的前n个元素。

例如，以下代码将对一个整数集合进行筛选、映射和排序操作：

代码语言：javascript复制

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
List<Integer> result = numbers.stream()
    .filter(n -> n % 2 == 0) // 过滤偶数
    .map(n -> n * 2)         // 映射为原来的2倍
    .sorted()                // 排序
    .collect(Collectors.toList()); // 收集结果

终端操作

终端操作是流的最后一步操作，它会触发对流的计算并产生一个最终的结果。终端操作通常包括：

forEach(Consumer<T> action)：对流中的每个元素执行操作。
collect(Collector<T, A, R> collector)：将流中的元素收集到一个容器中。
toArray()：将流中的元素收集到数组中。
reduce(identity, accumulator)：对流中的元素进行归约操作，返回一个值。
count()：返回流中元素的数量。
min(comparator)：返回流中的最小元素。
max(comparator)：返回流中的最大元素。
allMatch(predicate)：检查流中的所有元素是否都满足条件。
anyMatch(predicate)：检查流中是否存在满足条件的元素。
noneMatch(predicate)：检查流中是否没有元素满足条件。
findFirst()：返回流中的第一个元素。
findAny()：返回流中的任意一个元素。

终端操作是流的最后一步，一旦调用终端操作，流将被消耗，不能再被复用。

示例：从集合中筛选特定条件的元素

让我们通过一个示例来演示Java Stream流的使用。假设我们有一个包含学生对象的集合，每个学生对象都有姓名、年龄和成绩属性。我们想从集合中筛选出年龄大于18岁且成绩优秀的学生。

代码语言：javascript复制

class Student {
    private String name;
    private int age;
    private double score;

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public double getScore() {
        return score;
    }

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

public class Main {
    public static void main(String[] args) {
        List<Student> students = Arrays.asList(
            new Student("Alice", 20, 90.0),
            new Student("Bob", 22, 85.5),
            new Student("Charlie", 19, 88.5),
            new Student("David", 21, 92.0),
            new Student("Eva", 18, 94.5)
        );

        List<Student> result = students.stream()
            .filter(student -> student.getAge() > 18 && student.getScore() >= 90.0)
            .collect(Collectors.toList());

        result.forEach(System.out::println);
    }
}

运行以上代码，将输出符合条件的学生信息：

代码语言：javascript复制

Student{name='Alice', age=20, score=90.0}
Student{name='David', age=21, score=92.0}

并行流

Java Stream还提供了并行流的支持，可以充分利用多核处理器的性能。只需将普通流转换为并行流，即可实现并行化处理。

代码语言：javascript复制

List<Student> result = students.parallelStream()
    .filter(student -> student.getAge() > 18 && student.getScore() >= 90.0)
    .collect(Collectors.toList());

需要注意的是，并行流在某些情况下可能会引发线程安全问题，因此在处理共享状态时要格外小心。

更多操作

当使用Java Stream流进行数据处理时，除了基本的过滤、映射、排序和归约等操作外，还有许多其他有用的中间操作和终端操作。在本节中，我将介绍一些常见的Stream流操作，帮助你更好地理解如何使用它们。

中间操作

1. `distinct()`

distinct()方法用于去除流中的重复元素，返回一个去重后的新流。

示例：

代码语言：javascript复制

List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);
List<Integer> distinctNumbers = numbers.stream()
    .distinct()
    .collect(Collectors.toList());

System.out.println(distinctNumbers); // 输出: [1, 2, 3, 4, 5]

2. `limit(n)`

limit(n)方法用于截取流中的前n个元素，返回一个包含前n个元素的新流。

示例：

代码语言：javascript复制

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
List<Integer> limitedNumbers = numbers.stream()
    .limit(5)
    .collect(Collectors.toList());

System.out.println(limitedNumbers); // 输出: [1, 2, 3, 4, 5]

3. `skip(n)`

skip(n)方法用于跳过流中的前n个元素，返回一个跳过前n个元素后的新流。

示例：

代码语言：javascript复制

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
List<Integer> skippedNumbers = numbers.stream()
    .skip(5)
    .collect(Collectors.toList());

System.out.println(skippedNumbers); // 输出: [6, 7, 8, 9, 10]

4. `flatMap()`

flatMap()方法用于将流中的每个元素映射成一个新的流，然后将这些新流合并成一个流。通常用于将嵌套的集合扁平化。

示例：

代码语言：javascript复制

List<List<Integer>> nestedLists = Arrays.asList(
    Arrays.asList(1, 2),
    Arrays.asList(3, 4),
    Arrays.asList(5, 6)
);

List<Integer> flattenedList = nestedLists.stream()
    .flatMap(Collection::stream)
    .collect(Collectors.toList());

System.out.println(flattenedList); // 输出: [1, 2, 3, 4, 5, 6]

终端操作

1. `forEach()`

forEach()方法用于对流中的每个元素执行指定的操作。

示例：

代码语言：javascript复制

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.stream()
    .forEach(name -> System.out.println("Hello, "   name));

2. `toArray()`

toArray()方法用于将流中的元素收集到数组中。

示例：

代码语言：javascript复制

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Integer[] numberArray = numbers.stream()
    .toArray(Integer[]::new);

3. `reduce(identity, accumulator)`

reduce()方法用于对流中的元素进行归约操作，返回一个值。identity是初始值，accumulator是归约函数。

示例：

代码语言：javascript复制

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
    .reduce(0, (a, b) -> a   b);

System.out.println(sum); // 输出: 15

4. `collect()`

collect()方法用于将流中的元素收集到一个集合或其他数据结构中。可以使用Collectors类提供的各种工厂方法创建不同类型的集合。

示例：

代码语言：javascript复制

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> collectedNames = names.stream()
    .collect(Collectors.toList());

Set<String> collectedSet = names.stream()
    .collect(Collectors.toSet());

Map<String, Integer> collectedMap = names.stream()
    .collect(Collectors.toMap(name -> name, String::length));

5. `min(comparator)` 和 `max(comparator)`

min(comparator)和max(comparator)方法用于查找流中的最小和最大元素，需要传入一个比较器（Comparator）来定义比较规则。

示例：

代码语言：javascript复制

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> minNumber = numbers.stream()
    .min(Integer::compareTo);

Optional<Integer> maxNumber = numbers.stream()
    .max(Integer::compareTo);

System.out.println(minNumber.orElse(0)); // 输出: 1
System.out.println(maxNumber.orElse(0)); // 输出: 5

6. `anyMatch(predicate)`、`allMatch(predicate)` 和 `noneMatch(predicate)`

这些方法用于检查流中的元素是否满足给定的条件。

anyMatch(predicate)：检查流中是否有任意一个元素满足条件。
allMatch(predicate)：检查流中的所有元素是否都满足条件。
noneMatch(predicate)：检查流中是否没有元素满足条件。

示例：

代码语言：javascript复制

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean anyGreaterThanThree = numbers.stream()
    .anyMatch(n -> n > 3);

boolean allGreaterThanThree = numbers.stream()
    .allMatch(n -> n > 3);

boolean noneGreaterThanTen = numbers.stream()
    .noneMatch(n -> n > 10);

System.out.println(anyGreaterThanThree); // 输出: true
System.out.println(allGreaterThanThree); // 输出: false
System.out.println(noneGreaterThanTen);  // 输出: true

7. `findFirst()` 和 `findAny()`

findFirst()方法返回流中的第一个元素（在串行流中通常是第一个元素，但在并行流中不确定），findAny()方法返回流中的任意一个元素。

示例：

代码语言：javascript复制

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
Optional<String> first = names.stream()
    .findFirst();

Optional<String> any = names.parallelStream()
    .findAny();

这些只是Java Stream流的一些常见操作，Stream API提供了更多的方法来处理数据。根据具体的需求，你可以组合这些操作来构建复杂的数据处理流程。希望这些示例能帮助你更好地理解和使用Java Stream流。

注意事项

在使用Java Stream流时，有一些注意事项需要考虑，以确保代码的正确性和性能。以下是一些常见的注意事项：

不可重用性： 一旦创建了一个Stream对象并执行了终端操作，该Stream就不能再被重用。如果需要对同一数据集进行多次处理，应该每次都创建新的Stream对象。
惰性求值： Stream是惰性求值的，中间操作只会在终端操作触发后才会执行。这意味着中间操作不会立即产生结果，而是在需要结果时才进行计算。这可以帮助节省计算资源，但也需要谨慎处理，以免产生意外的行为。
并行流的线程安全性： 如果使用并行流（parallelStream()），要确保Stream操作是线程安全的。一些操作可能会引发并发问题，需要适当的同步或避免使用并行流。
流的关闭： 如果你使用的是基于IO的流（如Files.lines()），需要确保在使用完后关闭流，以释放资源。
性能注意事项： Stream操作的性能可能会受到数据量的影响。在大数据集上使用Stream时，要注意性能问题，可以考虑使用并行流或其他优化方法。
空值处理： 在使用Stream时，要注意空值（null）的处理，避免空指针异常。可以使用filter、map等操作来过滤或转换空值。
有状态操作： 一些Stream操作是有状态的，例如sorted和distinct，它们可能需要缓存所有元素，因此在处理大数据集时要谨慎使用，以免导致内存溢出。
自定义收集器： 如果需要自定义收集器（Collector），要确保它的线程安全性和正确性，以便在Stream中使用。
不可变性： 推荐使用不可变对象和不可变集合来处理Stream，以避免并发问题。
了解Stream操作的复杂度： 不同的Stream操作具有不同的时间复杂度。了解操作的复杂度有助于选择最适合的操作来满足性能需求。

总之，使用Java Stream流可以编写更简洁和可读性强的代码，但在使用过程中需要考虑到流的惰性求值、线程安全性、性能等方面的注意事项，以确保代码的正确性和性能。

总结

Java Stream流是一项强大的特性，可以极大地简化集合数据的处理。通过中间操作和终端操作的组合，我们可以轻松地实现各种复杂的数据处理任务。同时，流还提供了并行处理的支持，可以充分利用多核处理器的性能。

要注意的是，流是一次性的，一旦调用了终端操作，流将被消耗，不能再被复用。此外，在使用并行流时要注意线程安全的问题。

希望本文能帮助你更好地理解和使用Java Stream流，提高代码的可读性和可维护性。如果你对Java Stream流还有更多的疑问或想要深入了解，可以查阅官方文档或进一步学习相关的教程和示例。 Happy coding!

java stream 基础集合终端

0 人点赞

【Java 基础篇】Java Stream 流详解

什么是Stream流？

创建Stream流

从集合创建流

从数组创建流

从文件创建流

流的操作

中间操作

终端操作

示例：从集合中筛选特定条件的元素

并行流

更多操作

中间操作

1. distinct()

2. limit(n)

3. skip(n)

4. flatMap()

终端操作

1. forEach()

2. toArray()

3. reduce(identity, accumulator)

4. collect()

5. min(comparator) 和 max(comparator)

6. anyMatch(predicate)、allMatch(predicate) 和 noneMatch(predicate)

7. findFirst() 和 findAny()

注意事项

总结

1. `distinct()`

2. `limit(n)`

3. `skip(n)`

4. `flatMap()`

1. `forEach()`

2. `toArray()`

3. `reduce(identity, accumulator)`

4. `collect()`

5. `min(comparator)` 和 `max(comparator)`

6. `anyMatch(predicate)`、`allMatch(predicate)` 和 `noneMatch(predicate)`

7. `findFirst()` 和 `findAny()`