Java- 流式处理

基本介绍

流式处理（Stream API）是Java 8 中引入的一项功能，它提供了一种更为声明式和函数式的方式来处理集合数据。通过使用流，可以更轻松、清晰地执行各种集合操作，如过滤、映射、聚合等。流可以用于处理数组、集合等数据源。

以下是一些流式处理的基本概念和操作：

1. 创建流：

   • 通过集合创建流：

     List<String> myList = Arrays.asList("a1", "a2", "b1", "c2", "c1");
     Stream<String> stream = myList.stream();
     

   • 通过数组创建流：

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

2. 中间操作：

   • 中间操作用于对流进行转换，但并不会触发最终的结果计算。
   • 示例：

     List<String> result = myList.stream()
                                .filter(s -> s.startsWith("c"))
                                .map(String::toUpperCase)
                                .sorted()
                                .collect(Collectors.toList());
     

3. 终端操作：

   • 终端操作会触发流的计算，产生最终的结果或副作用。
   • 示例：

     long count = myList.stream().filter(s -> s.startsWith("c")).count();
     

4. forEach：

   • 对流中的每个元素执行指定的操作。
   • 示例：

     myList.stream().forEach(System.out::println);
     

5. Collectors：

   • 用于将流的元素累积到一个可变的结果容器中，如列表、集合等。
   • 示例：

     List<String> resultList = myList.stream()
                                     .filter(s -> s.startsWith("c"))
                                     .collect(Collectors.toList());
     

6. Map 操作：

   • 将流中的元素映射到另一个值。
   • 示例：

     List<Integer> lengths = myList.stream()
                                   .map(String::length)
                                   .collect(Collectors.toList());
     

7. Reduce 操作：

   • 将流中的元素进行归约操作，得到单一的结果。
   • 示例：

     Optional<String> concatenated = myList.stream()
                                          .reduce((s1, s2) -> s1 + s2);
     

流式处理提供了一种更简洁、可读性更高的方式来处理集合数据，同时也能够更好地利用多核架构，提高性能。

示例1

假设有一个包含一些Person对象的列表，每个Person对象有姓名和年龄属性。我们可以使用流式处理对这个列表进行一些操作，例如筛选年龄在30岁以上的人，并按姓名排序。以下是一个简单的例子：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

class Person {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

public class StreamExample {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
                new Person("Alice", 28),
                new Person("Bob", 35),
                new Person("Charlie", 30),
                new Person("David", 25),
                new Person("Eva", 32)
        );

        // 使用流进行操作
        List<String> result = people.stream()
                .filter(person -> person.getAge() > 30) // 筛选年龄大于30的人
                .sorted((p1, p2) -> p1.getName().compareTo(p2.getName())) // 按姓名排序
                .map(Person::getName) // 提取姓名
                .collect(Collectors.toList()); // 收集结果

        // 输出结果
        System.out.println(result); // 输出: [Charlie, Eva]
    }
}

在这个例子中，我们使用了流式处理来筛选年龄大于30的人，按姓名排序，并最终提取出姓名列表。这样的代码更为清晰和简洁，同时提供了更好的可读性。

示例2

Reduce 操作是流式处理中用于将流中的元素进行归约操作，最终得到单一结果的操作。归约操作可以是求和、求积、查找最大/最小值等。以下是一个求和的例子：

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

public class ReduceExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        // 使用 reduce 操作求和
        // 参数1: 初始值，参数2: BinaryOperator
        int sum = numbers.stream()
                .reduce(0, (a, b) -> a + b);

        System.out.println("Sum: " + sum); // 输出: Sum: 15
    }
}

在这个例子中，reduce 操作接受两个参数：初始值和一个 BinaryOperator。BinaryOperator 是一个函数接口，它接受两个参数并返回一个结果。在这里，Lambda表达式 (a, b) -> a + b 表示将两个参数相加。

在流中的元素依次执行这个归约操作，初始值是0，第一次操作为 0 + 1，第二次操作为 (0 + 1) + 2，以此类推，最终得到总和为15。

实际上，reduce 可以进行更复杂的归约操作，如查找最大/最小值、连接字符串等。