Java8 Stream API 详解:流式编程进行数据处理

简介: Java8 Stream API 详解:流式编程进行数据处理


前言


Java8中有两大最为重要的改变。第一个是 Lambda 表达式;另外一个则是 Stream API。


Stream 是 Java8 中处理集合的关键抽象概念,它可以指定你希望对集合进行的操作,可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作,就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之,Stream API 提供了一种高效且易于使用的处理数据的方式


流是数据渠道,用于操作数据源(集合、数组等)所生成的元素序列。“集合讲的是数据,流讲的是计算!”


注意:


① Stream 自己不会存储元素。


② Stream 不会改变源对象。相反,他们会返回一个持有结果的新Stream。


③ Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

Stream API的三个阶段


在Java中,Stream 是Java 8引入的一个新概念,用于处理集合(Collections)数据的一种抽象。Java的Stream API 提供了一种声明式的方式来操作数据集合,可以用更简洁、可读性更强的代码来进行集合的操作。


Java Stream API的操作可以分为三个阶段:


1. 创建流(Creation of Stream): 这个阶段涉及到从不同的数据源创建流,可以是集合、数组、I/O通道等。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream = numbers.stream();


2. 中间操作(Intermediate Operations): 这个阶段包括对流的转换操作,可以对流进行过滤、映射、排序等操作。这些操作并不会改变原始数据源,而是返回一个新的流。

Stream<Integer> filteredStream = stream.filter(x -> x > 2);


3. 终端操作(Terminal Operations): 这个阶段是对流进行最终操作,触发流的遍历,可以产生一个结果或者副作用。终端操作是流的最后一个操作,执行后流将不可再用。

long count = filteredStream.count();

这三个阶段的设计使得可以通过链式调用的方式组合多个操作,从而编写更为清晰和简洁的代码。这种方式也有助于提高代码的可读性和可维护性。


当然,这里只是对于Stream API三个阶段的概述,只是告诉大家,简单分为三个阶段,至于三个阶段里面有哪些主要的方法,我们在下文进行详细叙述,这里我们点到为止!现在,大家心里面就应该有这么一个蓝图,或者是基本框架,知道我们接下来将会沿着那个几个方向展开叙述!

创建Stream流

在Java中,你可以使用多种方式来创建Stream流。

从集合创建:

使用集合类的 stream() 或 parallelStream() 方法可以创建对应的流。例如:

List<String> list = Arrays.asList("apple", "banana", "orange");
Stream<String> streamFromList = list.stream();

从数组创建:

使用 Arrays.stream() 方法可以从数组中创建流:

String[] array = {"apple", "banana", "orange"};
Stream<String> streamFromArray = Arrays.stream(array);

通过Stream的静态方法创建:

Stream 类提供了静态方法 of(),可以传入一系列元素来创建流:

Stream<String> stream = Stream.of("apple", "banana", "orange");

使用Stream的generate和iterate方法:

Stream 类还提供了 generate 和 iterate 方法,用于生成无限流:

// 生成包含随机整数的无限流
Stream<Integer> infiniteStream = Stream.generate(() -> (int) (Math.random() * 100));
 
// 从指定的起始值开始,按照某个规则生成无限流
Stream<Integer> sequentialStream = Stream.iterate(1, n -> n + 1);

通过文件生成流:

java.nio.file.Files 类提供了静态方法 lines(),可以用来读取文件内容并生成流:

Path path = Paths.get("example.txt");
Stream<String> fileLines = Files.lines(path);


使用正则表达式生成流:

Pattern 类的 splitAsStream 方法可以根据正则表达式将字符串分割成流:

String text = "apple,orange,banana";
Stream<String> textStream = Pattern.compile(",").splitAsStream(text);

Stream API中间操作

Stream API 提供了许多中间操作,用于对流进行转换、筛选和处理。


filter

用于筛选元素,根据指定的条件保留符合条件的元素。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> filteredStream = numbers.stream().filter(x -> x > 2);


map

对流中的每个元素应用指定的函数,并将结果映射为一个新的元素。

List<String> words = Arrays.asList("apple", "banana", "orange");
Stream<Integer> wordLengths = words.stream().map(String::length);


flatMap

将流中的每个元素都转换为一个流,然后将这些流连接起来成为一个流。

List<List<Integer>> numbers = Arrays.asList(
    Arrays.asList(1, 2),
    Arrays.asList(3, 4),
    Arrays.asList(5, 6)
);
 
Stream<Integer> flatStream = numbers.stream().flatMap(List::stream);

distinct

去除流中的重复元素。

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

sorted

对流中的元素进行排序。

List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6);
Stream<Integer> sortedNumbers = numbers.stream().sorted();

peek

对流中的每个元素执行操作,主要用于调试和观察流中的元素。

List<String> words = Arrays.asList("apple", "banana", "orange");
Stream<String> peekStream = words.stream().peek(System.out::println);


limit 和 skip

limit 用于截断流,保留指定数量的元素,而 skip 则用于跳过指定数量的元素。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> limitedStream = numbers.stream().limit(3);
Stream<Integer> skippedStream = numbers.stream().skip(2);

Stream API终端操作

Stream API 的终端操作用于触发对流的最终操作,产生结果或者引起副作用。

forEach

对流中的每个元素执行指定的操作。

List<String> words = Arrays.asList("apple", "banana", "orange");
words.stream().forEach(System.out::println);

toArray

将流中的元素转换为数组。

List<String> words = Arrays.asList("apple", "banana", "orange");
String[] wordArray = words.stream().toArray(String[]::new);

reduce

对流中的元素进行归约操作,可以用于求和、求最大值、最小值等。

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

collect

将流中的元素收集到一个集合中,例如 List、Set 或 Map。

List<String> words = Arrays.asList("apple", "banana", "orange");
List<String> collectedWords = words.stream().collect(Collectors.toList());


count

返回流中的元素数量。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
long count = numbers.stream().count();

anyMatch、allMatch 和 noneMatch

用于检查流中是否存在满足指定条件的元素。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean anyGreaterThanThree = numbers.stream().anyMatch(x -> x > 3);
boolean allGreaterThanTwo = numbers.stream().allMatch(x -> x > 2);
boolean noneGreaterThanFive = numbers.stream().noneMatch(x -> x > 5);


findAny 和 findFirst

返回流中的任意一个元素或者第一个元素。

List<String> words = Arrays.asList("apple", "banana", "orange");
Optional<String> anyWord = words.stream().findAny();
Optional<String> firstWord = words.stream().findFirst();

min 和 max

返回流中的最小值或最大值。

List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6);
Optional<Integer> minNumber = numbers.stream().min(Integer::compare);
Optional<Integer> maxNumber = numbers.stream().max(Integer::compare);

注意事项

使用Stream API时,有一些需要注意的重要事项,以确保正确、高效地利用这一功能:


只能使用一次: 一个 Stream 实例只能被消费(执行终端操作)一次。如果你尝试对已经使用过的流进行其他终端操作,会抛出 IllegalStateException 异常。如果需要再次操作,可以重新创建一个新的流。

List<String> words = Arrays.asList("apple", "banana", "orange");
Stream<String> wordStream = words.stream();
 
// 正确的做法
long count = wordStream.count();
 
// 错误的做法,会抛出IllegalStateException
long anotherCount = wordStream.count();

及早退出: 在处理大量数据时,及早退出可以提高性能。使用 anyMatch()、findFirst() 等终端操作时,一旦找到符合条件的元素,就会立即返回,不再继续处理后续元素。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean anyGreaterThanThree = numbers.stream().anyMatch(x -> {
    System.out.println("Checking: " + x);
    return x > 3;
});


并行流的谨慎使用: Stream API 提供了并行流的支持,可以通过 parallel() 方法将顺序流转换为并行流。但并不是所有的场景都适合使用并行流,因为在某些情况下,并行流可能会导致性能下降,甚至出现并发问题。在并行流的使用上需要注意线程安全等问题。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
long count = numbers.parallelStream().filter(x -> x > 2).count();

使用适当的数据结构: 在创建流时,选择适当的数据结构能够影响流操作的性能。例如,ArrayList 在顺序访问时性能较好,而 LinkedList 在随机访问时性能较好。

总结

总体而言,了解Stream API的使用原则,结合具体的业务场景和性能需求,能够更好地利用Stream API完成任务。注意流的延迟计算特性,避免副作用,可以使代码更加清晰、可读,并提高代码的可维护性。


相关文章
|
3天前
|
Java API
深入探讨 Java 8 集合操作:全面解析 Stream API 的强大功能
深入探讨 Java 8 集合操作:全面解析 Stream API 的强大功能
12 2
|
4天前
|
安全 Java 程序员
Java8实战-新的日期和时间API
Java8实战-新的日期和时间API
15 3
|
1天前
|
SQL 关系型数据库 API
实时计算 Flink版产品使用问题之如何使用stream api
实时计算Flink版作为一种强大的流处理和批处理统一的计算框架,广泛应用于各种需要实时数据处理和分析的场景。实时计算Flink版通常结合SQL接口、DataStream API、以及与上下游数据源和存储系统的丰富连接器,提供了一套全面的解决方案,以应对各种实时计算需求。其低延迟、高吞吐、容错性强的特点,使其成为众多企业和组织实时数据处理首选的技术平台。以下是实时计算Flink版的一些典型使用合集。
|
5天前
|
并行计算 算法 Java
Java8实战-并行数据处理与性能(二)
Java8实战-并行数据处理与性能(二)
10 0
|
5天前
|
并行计算 算法 Java
Java8实战-并行数据处理与性能(一)
Java8实战-并行数据处理与性能(一)
9 0
|
5天前
|
存储 Java API
Java8实战-使用Stream
Java8实战-使用Stream
7 0
Java8实战-使用Stream
|
10月前
|
Java
Java8中stream流处理数据21个小案例(学习使用)
Java8中stream流处理数据21个小案例(学习使用)
72 0
|
SQL 存储 前端开发
【Java技术指南】「Java8技术盲区」在奔向Java13的同时,也让我们仔细研究一下Stream的学习认知!
【Java技术指南】「Java8技术盲区」在奔向Java13的同时,也让我们仔细研究一下Stream的学习认知!
119 0
【Java技术指南】「Java8技术盲区」在奔向Java13的同时,也让我们仔细研究一下Stream的学习认知!
|
Java 程序员 API
Java 8 Stream API学习总结
Java 8 API添加了一个新的抽象称为流Stream,可以让你以一种声明的方式处理数据。Stream API可以极大提高Java程序员的生产力,让程序员写出高效率、干净、简洁的代码。这种风格将要处理的元素集合看作一种流, 流在管道中传输, 并且可以在管道的节点上进行处理, 比如筛选, 排序,聚合等。
993 0
|
Java API 安全
JAVA8--Stream学习
Stream是什么 怎么使用Stream Stream的建立 Stream中的元素操作 Stream聚合操作 Stream结果处理 Stream分组操作 Stream注意事项 Stream是什么 书上说Stream是对JAVA中对集合处理的抽象,在我看来Stream更像是对java集合的一次扩展,因为Stream中的API都是我们对集合操作中可能遇
1761 0