Java8 Stream API：从新手到大师，一文带你领略数据流的魅力！

KK_crazy

已于 2024-03-11 16:03:09 修改

阅读量975

点赞数 22

文章标签： stable diffusion chatgpt ai gpt 人工智能 java

于 2024-03-11 10:49:23 首次发布

本文链接：https://blog.csdn.net/weixin_42373241/article/details/136615751

版权

全套面试题已打包2024最全大厂面试题无需C币点我下载或者在网页打开

玩转 GPU AI绘画、AI讲话、翻译,GPU点亮AI想象空间

AI绘画 stable diffusion Midjourney 官方GPT文档 AIGC百科全书资料收集

Java8 Stream API：从入门到实战

Java 8引入了一个新的抽象层——Stream API，它提供了一种更加简洁、函数式的方式来处理集合数据。本文将带你从基础概念开始，逐步深入到Stream API的实际应用，并通过一系列代码示例，让你掌握这一强大的工具。

1. Stream API 基础

1.1 什么是Stream？

Stream API可以让你以一种声明式的方式处理数据集合。它支持并行操作，可以极大地提高数据处理的效率。Stream不是数据结构，而是一个可以进行聚合操作的数据集合视图。

1.2 创建Stream

在Java中，可以通过集合的stream()方法或者数组的stream()方法来创建Stream。

List<String> list = Arrays.asList("Apple", "Banana", "Cherry");
Stream<String> stream = list.stream();

1.3 Stream的不可变性

Stream是不可变的。一旦创建，就不能修改其底层的数据源。任何试图修改Stream的操作都会返回一个新的Stream。

2. Stream API 的中间操作

中间操作是对Stream进行的一系列操作，它们会返回一个新的Stream，这些操作是延迟执行的，直到终端操作被执行。

2.1 filter

filter用于过滤元素，接受一个Predicate作为参数。

stream.filter(s -> s.startsWith("B"))
    .forEach(System.out::println); // 输出：Banana

2.2 map

map用于转换元素，接受一个Function作为参数。

stream.map(s -> s.toLowerCase())
    .forEach(System.out::println); // 输出：apple, banana, cherry

2.3 distinct

distinct用于去除重复元素。

stream.distinct()
    .forEach(System.out::println); // 输出：Apple, Banana, Cherry

3. Stream API 的终端操作

终端操作是Stream操作链的结束点，它们会返回一个非Stream的结果，或者产生一个副作用。

3.1 forEach

forEach用于执行副作用，它接受一个Consumer作为参数。

stream.forEach(System.out::println); // 输出：Apple, Banana, Cherry

3.2 collect

collect用于收集Stream中的元素，返回一个结果。

List<String> collected = stream.collect(Collectors.toList());

3.3 reduce

reduce用于将Stream中的元素组合起来，返回一个单一的值。

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

4. 实战案例：统计文本中的单词

假设我们有一个文本文件，我们需要统计每个单词出现的次数。我们可以使用Stream API来完成这个任务。

import java.nio.file.*;
import java.util.*;
import java.util.stream.*;

public class WordCounter {
    public static void main(String[] args) {
        try (Stream<String> lines = Files.lines(Paths.get("sample.txt"))) {
            long wordCount = lines
                .flatMap(line -> Arrays.stream(line.split("\\W+"))) // 使用正则表达式分割单词
                .filter(Objects::nonNull) // 过滤空字符串
                .distinct() // 去除重复单词
                .peek(System.out::println) // 输出单词，用于调试
                .count(); // 计数

            System.out.println("Total unique words: " + wordCount);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

5. 并行Stream

Java 8的Stream API还支持并行操作，可以利用多核处理器的优势来加速数据处理。

long parallelWordCount = lines
    .parallel()
    .flatMapToInt(line -> Arrays.stream(line.split("\\W+")).mapToInt(String::length))
    .sum(); // 计算总字符数

System.out.println("Total characters: " + parallelWordCount);

标题：Java8 Stream API：数据转换与聚合的魔法书

在Java 8中，Stream API不仅仅是一个简单的迭代工具，它还提供了强大的数据转换和聚合功能。这些功能使得我们可以以一种更加声明式和函数式的方式来处理复杂的数据集合。下面，我们将通过一些示例来探索如何使用Stream API进行复杂的数据转换和聚合操作。

1. 数据转换

1.1 使用`map`进行简单转换

map操作是Stream API中最基础的转换操作，它接受一个Function作为参数，将每个元素应用该函数并返回一个新的Stream。

List<String> fruits = Arrays.asList("Apple", "Banana", "Cherry");
List<String> lowerCaseFruits = fruits.stream()
    .map(String::toLowerCase)
    .collect(Collectors.toList());

1.2 使用`flatMap`进行复杂转换

flatMap操作可以处理嵌套的集合，它接受一个Function作为参数，将每个元素应用该函数，并将结果连接成一个流。

List<List<String>> nestedFruits = Arrays.asList(
    Arrays.asList("Apple", "Banana"),
    Arrays.asList("Cherry", "Date")
);
Stream<String> flatFruits = nestedFruits.stream()
    .flatMap(Collection::stream);

1.3 使用`mapToDouble`、`mapToInt`、`mapToLong`进行数值转换

这些方法允许你将Stream中的元素转换为数值类型，并返回对应的DoubleStream、IntStream或LongStream。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
IntStream numberStream = numbers.stream()
    .mapToInt(Integer::intValue);

2. 数据聚合

2.1 使用`collect`进行聚合

collect操作是Stream API中用于聚合数据的关键方法。它接受一个Collector作为参数，可以执行复杂的聚合操作。

List<String> fruits = Arrays.asList("Apple", "Banana", "Cherry");
String allFruits = fruits.stream()
    .collect(Collectors.joining(", ")); // 结果：Apple, Banana, Cherry

2.2 使用`reduce`进行累加

reduce操作可以将Stream中的所有元素组合成一个单一的值。它接受一个BinaryOperator作为参数。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> sum = numbers.stream()
    .reduce((a, b) -> a + b); // 结果：15

2.3 使用`groupingBy`进行分组

groupingBy操作可以根据某个属性对Stream中的元素进行分组。

List<Person> people = // ... 初始化人员列表
Map<String, List<Person>> groupedByGender = people.stream()
    .collect(Collectors.groupingBy(Person::getGender));

2.4 使用`joining`连接字符串

joining是一个特殊的Collector，它可以将Stream中的字符串元素连接成一个单一的字符串。

List<String> fruits = Arrays.asList("Apple", "Banana", "Cherry");
String allFruitsJoined = fruits.stream()
    .collect(Collectors.joining(", ")); // 结果：Apple, Banana, Cherry

3. 实战案例：处理复杂数据

假设我们有一个包含订单和订单项的复杂数据结构，我们需要计算每个客户的总消费额。

public class Order {
    private List<OrderItem> items;
    // ... 其他属性和方法
}

public class OrderItem {
    private double price;
    // ... 其他属性和方法
}

public class Customer {
    private List<Order> orders;
    // ... 其他属性和方法
}

// ... 初始化客户和订单数据

Map<Customer, Double> customerSpending = customers.stream()
    .collect(Collectors.groupingBy(
        Customer::getCustomerIdentifier,
        Collectors.summingDouble(customer -> customer.getOrders().stream()
            .mapToDouble(order -> order.getItems().stream()
                .mapToDouble(item -> item.getPrice())
                .sum())
            .sum())
    ));

在这个例子中，我们首先根据客户标识符对订单进行分组，然后对每个客户的订单项进行求和，最后计算总消费额。

在Java 8的Stream API中，limit和skip方法是两个非常有用的中间操作，它们允许你控制流的大小，即你可以限制流中元素的数量，或者跳过流中的前N个元素。这两个方法通常用于处理大型数据集时的性能优化，或者在需要处理数据子集时的场景。

`limit`方法

limit方法接受一个整数参数，它限制了流中元素的数量。当你调用limit(n)时，流将只包含前N个元素。如果流中的元素少于N个，那么流将包含所有元素。

List<String> fruits = Arrays.asList("Apple", "Banana", "Cherry", "Date", "Elderberry");
Stream<String> limitedStream = fruits.stream().limit(3);

limitedStream.forEach(System.out::println); // 输出：Apple, Banana, Cherry

在这个例子中，我们只处理了列表中的前三个水果。

`skip`方法

skip方法也接受一个整数参数，但它的作用是跳过流中的前N个元素。流将包含从第N+1个元素开始的所有元素。

Stream<String> skippedStream = fruits.stream().skip(2);

skippedStream.forEach(System.out::println); // 输出：Cherry, Date, Elderberry

在这个例子中，我们跳过了列表中的前两个水果，只处理了剩余的水果。

结合使用`limit`和`skip`

你可以结合使用limit和skip来进一步控制流的大小。例如，如果你想要处理列表中的第三个到第五个元素，你可以先跳过前两个，然后限制结果流的大小为3。

Stream<String> combinedStream = fruits.stream()
    .skip(2) // 跳过前两个元素
    .limit(3); // 限制结果流的大小为3

combinedStream.forEach(System.out::println); // 输出：Cherry, Date, Elderberry

实际应用

在实际应用中，limit和skip方法常用于分页功能，例如在Web应用中，你可能需要显示用户列表的特定页。通过skip跳过前面的用户，然后使用limit来限制每页显示的用户数量。

int pageNumber = 2; // 当前页码
int pageSize = 10; // 每页显示的用户数量

Stream<User> usersStream = users.stream()
    .skip((pageNumber - 1) * pageSize) // 跳过前面的用户
    .limit(pageSize); // 限制每页的用户数量

usersStream.forEach(user -> System.out.println(user.getName()));

在这个例子中，我们计算了跳过的用户数量，然后使用limit来确保每页只显示指定数量的用户。

如果你需要更多内容或者有其他问题，请告诉我，我会继续为你提供帮助。

Java 8 Stream API提供了多种方法来优化数据处理，除了limit和skip之外，还包括以下几种常用的优化方法：

1. `filter`方法

filter方法用于根据给定条件筛选流中的元素。通过只处理满足特定条件的元素，可以减少不必要的计算和资源消耗。

Stream<String> stream = ...;
stream.filter(s -> s.length() > 5).forEach(System.out::println);

2. `distinct`方法

distinct方法用于去除流中的重复元素。当你只需要唯一值时，这个方法可以减少数据的处理量。

Stream<String> stream = ...;
stream.distinct().forEach(System.out::println);

3. `sorted`或`sorted`方法（自然排序或自定义排序）

sorted方法用于对流中的元素进行排序。对于已经排序的数据，使用sorted可以避免不必要的排序操作。如果需要自定义排序规则，可以使用sorted(Comparator)。

Stream<String> stream = ...;
stream.sorted().forEach(System.out::println); // 自然排序
stream.sorted(Comparator.reverseOrder()).forEach(System.out::println); // 逆序排序

4. `map`和`flatMap`方法

map方法用于对流中的每个元素应用一个函数，并返回一个新的流。flatMap则用于处理嵌套的集合，它可以将流中的每个元素转换成另一个流，然后将所有流连接起来。

Stream<String> stream = ...;
stream.map(String::toUpperCase).forEach(System.out::println); // 转换为大写
stream.flatMap(Arrays::stream).forEach(System.out::println); // 处理嵌套数组

5. `parallelStream`方法

parallelStream方法可以将流转换为并行流，以便利用多核处理器的并行处理能力。但请注意，并非所有的操作都适合并行处理，不当使用可能会导致性能下降。

List<String> list = ...;
list.parallelStream().forEach(System.out::println);

6. `collect`方法

collect方法用于将流中的元素收集到一个特定的数据结构中。通过选择合适的收集器（Collector），可以优化数据的聚合和转换过程。

Stream<String> stream = ...;
List<String> collected = stream.collect(Collectors.toList());

7. `peek`方法

peek方法允许你在流操作中插入一个操作，用于调试或记录日志，而不会改变流中的元素。

Stream<String> stream = ...;
stream.peek(System.out::println).forEach(System.out::println);

8. `takeWhile`和`dropWhile`方法

这两个方法在流操作中相对较新，它们允许你根据条件来获取流中的元素序列。takeWhile在条件不再满足时停止获取元素，而dropWhile则在条件不再满足时开始获取元素。

Stream<String> stream = ...;
stream.takeWhile(s -> s.startsWith("A")).forEach(System.out::println); // 获取以A开头的元素

9. `min`和`max`方法

min和max方法用于获取流中最小或最大的元素。它们通常用于快速获取比较结果，而不需要处理整个流。

Optional<String> min = stream.min(Comparator.comparing(String::length));
Optional<String> max = stream.max(Comparator.comparing(String::length));

结语

Java 8 Stream API的这些方法提供了丰富的数据处理能力，可以帮助你以更高效、更简洁的方式处理数据。在实际应用中，合理地组合使用这些方法可以极大地提升数据处理的性能和代码的可读性。记得在使用并行流时要小心，因为并行处理可能会引入额外的复杂性，比如线程安全问题和性能瓶颈。希望这些信息对你有所帮助！如果你有任何问题或想要了解更多，请在评论区留言，我会尽快回复你。别忘了点赞和分享，让更多的朋友受益！👍🌟

以上是关于Java 8 Stream API优化数据处理的一些方法。如果你有特定的场景或问题，可以提供更多信息，我会尽力为你提供更详细的解答。

KK_crazy

关注

22
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
Java8 Stream API：从新手到大师，一文带你领略数据流的魅力！

Stream API可以让你以一种声明式的方式处理数据集合。它支持并行操作，可以极大地提高数据处理的效率。Stream不是数据结构，而是一个可以进行聚合操作的数据集合视图。sorted方法用于对流中的元素进行排序。对于已经排序的数据，使用sorted可以避免不必要的排序操作。如果需要自定义排序规则，可以使用。// 自然排序// 逆序排序Java 8 Stream API的这些方法提供了丰富的数据处理能力，可以帮助你以更高效、更简洁的方式处理数据。
复制链接

扫一扫