Java8 Stream流API使用简介
概述
本文介绍Java8 Streams从创建到并行执行的实际使用例子，涉及 Java8（lambda表达式、Optional、方法引用）和流API的基本知识。
流创建
有很多方法可以创建不同源的流实例。一旦创建，实例将不会修改其源，因此允许从单个源创建多个实例。
空流
Stream<String> streamEmpty = Stream.empty();
常在创建时使用empty方法，以避免对没有元素的流返回null：
public Stream<String> streamOf(List<String> list) {
return list == null || list.isEmpty() ? Stream.empty() : list.stream();
}
集合流
可以创建任何类型的集合（集合、列表、数组）的流：
Collection<String> collection = Arrays.asList("a", "b", "c");
Stream<String> streamOfCollection = collection.stream();
Stream<String> streamOfArray = Stream.of("a", "b", "c");
还可以从现有数组或数组的一部分创建流：
String[] arr = new String[]{"a", "b", "c"};
Stream<String> streamOfArrayFull = Arrays.stream(arr);
Stream<String> streamOfArrayPart = Arrays.stream(arr, 1, 3);
Stream.builder()
当使用builder时，应该在语句的右侧部分额外指定所需的类型，否则build方法将创建Stream＜Object＞的实例：
Stream<String> streamBuilder =
Stream.<String>builder().add("a").add("b").add("c").build();
Stream.generate()
generate方法接受Supplier＜T＞来生成元素。由于生成的流是无限的，开发人员应该指定所需的大小：
Stream<String> streamGenerated =
Stream.generate(() -> "element").limit(10);
Stream.iterate()
Stream<Integer> streamIterated = Stream.iterate(40, n -> n + 2).limit(20);
结果流的第一个元素是iterate方法的第一个参数。创建之后的每个元素时，指定的函数将应用于前一个元素。在上面的例子中，第二个元素将是42。
Primitives基元流
Java8提供了从三种基本类型创建流的可能性：int、long和double。由于Stream＜T＞是一个泛型接口，并且无法将基元用作泛型的类型参数，因此创建了三个新的特殊接口：IntStream、LongStream和DoubleStream。
使用该接口可以减少不必要的自动装箱，从而提高效率：
IntStream intStream = IntStream.range(1, 3);
LongStream longStream = LongStream.rangeClosed(1, 3);
range（int startInclusive，int endExclusive）方法创建从第一个参数到第二个参数的有序流。它以等于1的步长递增后续元素的值。结果不包括最后一个参数，它只是序列的一个上界。
rangeClosed（int startInclusive，int endInclusive）方法执行相同的操作，但只有一个区别，即包括第二个元素。我们可以使用这两种方法来生成三种类型的基元流中的任何一种。
自Java 8以来，Random类提供了一系列用于生成基元流的方法。例如，以下代码创建了一个DoubleStream，它有三个元素：
Random random = new Random();
DoubleStream doubleStream = random.doubles(3);
字符串流
在String类的chars（）方法的帮助下，我们还可以使用String作为创建流的源。由于JDK中没有CharStream的接口，因此我们使用IntStream来表示字符流。
IntStream streamOfChars = "abc".chars();
以下示例根据指定的RegEx将字符串分解为子字符串：
Stream<String> streamOfString =
Pattern.compile(", ").splitAsStream("a, b, c");
文件流
此外，Java NIO类Files允许我们通过line（）方法生成文本文件的Stream＜String＞。文本的每一行都成为流的一个元素：
Path path = Paths.get("C:\\file.txt");
Stream<String> streamOfStrings = Files.lines(path);
Stream<String> streamWithCharset =
Files.lines(path, Charset.forName("UTF-8"));
引用流
记住Java 8流是不能重用的，这一点非常重要。
Stream<String> stream =
Stream.of("a", "b", "c").filter(element -> element.contains("b"));
Optional<String> anyElement = stream.findAny();
Optional<String> firstElement = stream.findFirst();
尝试重用相同的引用将触发IllegalStateException：这种行为是合乎逻辑的。流的设计是为了以函数样式将有限的操作序列应用于元素源，而不是存储元素。
因此，为了使以前的代码正常工作，应该进行一些更改：
List<String> elements =
Stream.of("a", "b", "c").filter(element -> element.contains("b"))
.collect(Collectors.toList());
Optional<String> anyElement = elements.stream().findAny();
Optional<String> firstElement = elements.stream().findFirst();
懒调用
使用流的正确和最方便的方法是通过流管道，它是流源、中间操作和终端操作的链：
List<String> list = Arrays.asList("abc1", "abc2", "abc3");
long size = list.stream().skip(1)
.map(element -> element.substring(0, 3)).sorted().count();
中间操作是惰性的。这意味着只有在终端操作执行需要时才会调用它们。
例如，让我们调用方法wasCalled（），它每次调用时都会增加一个内部计数器：
private long counter;
private void wasCalled() {
counter++;
}
现在，让我们从操作filter（）中调用方法wasCalled（）：
List<String> list = Arrays.asList(“abc1”, “abc2”, “abc3”);
counter = 0;
Stream<String> stream = list.stream().filter(element -> {
wasCalled();
return element.contains("2");
});
由于我们有三个元素的源，可以假设filter（）方法将被调用三次，计数器变量的值将为3。然而，运行此代码根本不会更改计数器，它仍然为零，因此filter（）方法甚至没有被调用过一次，缺少终端操作的原因。
让我们通过添加map（）操作和终端操作findFirst（）来稍微重写一下这段代码。我们还将在日志记录的帮助下添加跟踪方法调用顺序的功能：
Optional<String> stream = list.stream().filter(element -> {
log.info("filter() was called");
return element.contains("2");
}).map(element -> {
log.info("map() was called");
return element.toUpperCase();
}).findFirst();
生成的日志显示，我们调用了filter（）方法两次，调用了map（）方法一次。这是因为管道是垂直执行的。
在示例中，流的第一个元素不满足过滤器的谓词。然后，调用了第二个元素的filter（）方法，通过管道进入map（）方法，findFirst（）操作只满足一个元素，因此调用结束返回。
因此，在这个特定的例子中，惰性调用使我们能够避免两个方法调用，一个用于filter（），另一个用于map（）。
执行顺序
从性能的角度来看，正确的顺序是流管道中链操作最重要的方面之一：
long size = list.stream().map(element -> {
wasCalled();
return element.substring(0, 3);
}).skip(2).count();
执行此代码将使计数器的值增加3，这意味着我们调用了流的map（）方法三次，但返回的值是1。因此，生成的流只有一个元素，而无缘无故地执行了三次中的两次昂贵的map（）操作。
如果我们改变skip（）和map（）方法的顺序，计数器将只增加一个。因此，我们将只调用map（）方法一次：
long size = list.stream().skip(2).map(element -> {
wasCalled();
return element.substring(0, 3);
}).count();
这就引出了以下规则：减少流大小的中间操作应该放在应用于每个元素的操作之前。因此，我们需要将skip（）、filter（）和distinct（）等方法保留在流管道的顶部。
reduce()流聚合
流API默认提供了一些流聚合的操作：count（）、max（），min（）和sum（），如果需要自定义聚合，可以使用reduce（）和collect（）。
reduce具有以下参数：
identity：累加器的初始值，如果流为空并且没有任何可累加的内容，则为默认值；
accumulator累加器：一个指定元素聚合逻辑的函数。由于累加器为每一个步骤创建一个新值，所以新值的数量等于流的大小，只有最后一个值是有用的。
combiner组合器：一个聚合累加器结果的函数。只在并行模式下调用组合器。
现在，让我们看看这三种方法的作用：
OptionalInt reduced =
IntStream.range(1, 4).reduce((a, b) -> a + b);
reduced = 6 (1 + 2 + 3)
int reducedTwoParams =
IntStream.range(1, 4).reduce(10, (a, b) -> a + b);
reducedTwoParams = 16 (10 + 1 + 2 + 3)
int reducedParams = Stream.of(1, 2, 3)
.reduce(10, (a, b) -> a + b, (a, b) -> {
log.info("combiner was called");
return a + b;
});
结果将与前面的示例（16）相同，这意味着没有调用合并器。要使组合器工作，流应该是并行的：
int reducedParallel = Arrays.asList(1, 2, 3).parallelStream()
.reduce(10, (a, b) -> a + b, (a, b) -> {
log.info("combiner was called");
return a + b;
});
结果：36，组合器被调用了两次：流的每个元素添加到累加器运行三次，并且是并行进行的。因此，它们具有（10+1=11；10+2=12；10+3=13；）。现在组合器可以合并这三个结果。它需要两次迭代（12+13=25；25+11=36）。
collect()收集器
流API已经为大多数常见操作创建了预定义的收集器。
List<Product> productList = Arrays.asList(new Product(23, "potatoes"),
new Product(14, "orange"), new Product(13, "lemon"),
new Product(23, "bread"), new Product(13, "sugar"));
将流转换为集合：
List<String> collectorCollection =
productList.stream().map(Product::getName).collect(Collectors.toList());
还原为字符串：
String listToString = productList.stream().map(Product::getName)
.collect(Collectors.joining(", ", "[", "]"));
joiner（）方法可以有1到3个参数（分隔符、前缀、后缀）。
处理流中所有数字元素的平均值：
int summingPrice = productList.stream()
.collect(Collectors.summingInt(Product::getPrice));
方法averagingXX（）、summingXX（）和summaryzingXX（）可以处理基元（int、long、double）及其包装类（Integer、long、double）。这些方法的一个更强大的功能是提供映射。因此，开发人员不需要在collect（）方法之前使用额外的map（）操作。
IntSummaryStatistics statistics = productList.stream()
.collect(Collectors.summarizingInt(Product::getPrice));
结果将是一个与此“IntSummaryStatistics｛count＝5，sum＝86，min＝13，average＝17，max＝23｝”相同的字符串
根据指定的函数对流的元素进行分组：
Map<Integer, List<Product>> collectorMapOfLists = productList.stream()
.collect(Collectors.groupingBy(Product::getPrice));
根据一些谓词将流的元素分组：
Map<Boolean, List<Product>> mapPartioned = productList.stream()
.collect(Collectors.partitioningBy(element -> element.getPrice() > 15));
推进收集器时可执行附加转换：
Set<Product> unmodifiableSet = productList.stream()
.collect(Collectors.collectingAndThen(Collectors.toSet(),
Collections::unmodifiableSet));
如果出于某种原因应该创建自定义收集器，那么最简单的方法是使用收集器类型的of（）方法。
Collector<Product, ?, LinkedList<Product>> toLinkedList =
Collector.of(LinkedList::new, LinkedList::add,
(first, second) -> {
first.addAll(second);
return first;
});
LinkedList<Product> linkedListOfPersons =
productList.stream().collect(toLinkedList);
并行流
Java 8引入了一种以函数风格实现并行的方法。API允许我们创建并行流，以并行模式执行操作。当流的源是Collection或数组时，可以借助parallelStream（）方法实现：
Stream<Product> streamOfCollection = productList.parallelStream();
boolean isParallel = streamOfCollection.isParallel();
boolean bigPrice = streamOfCollection
.map(product -> product.getPrice() * 12)
.anyMatch(price -> price > 200);
如果流的源不是Collection或数组，则应使用parallel（）方法：
IntStream intStreamParallel = IntStream.range(1, 150).parallel();
boolean isParallel = intStreamParallel.isParallel();
在后台，Stream API自动使用ForkJoin框架并行执行操作。默认情况下，将使用公共线程池。
在并行模式下使用流时，请避免阻塞操作。当任务需要类似的执行时间时，最好使用并行模式。如果一项任务的持续时间比另一项长得多，则可能会减慢整个应用程序的工作流程。
并行模式下的流可以使用sequencial（）方法转换回顺序模式：
IntStream intStreamSequential = intStreamParallel.sequential();
boolean isParallel = intStreamSequential.isParallel();
结论
流API是一套功能强大但易于理解的工具，用于处理元素序列。如果使用得当，它可以减少大量代码，创建更可读的程序，并提高应用程序的生产力。在应用程序中，不要让实例化的流未被使用，避免导致内存泄漏。
相关阅读:
- Java程序中的“宝藏”，你知道它藏了什么吗？ (liqianqian1116, 2023-5-08)
- Python 实现栈的几种方式及其优劣 (liqianqian1116, 2023-5-09)
- 做到这些，你就成为了Python文件读取的高手！ (liqianqian1116, 2023-5-10)
- 使用开源 Python API 封装器与你的集群对话 (liqianqian1116, 2023-5-10)
- Python高级篇—测试和调试 (liqianqian1116, 2023-5-15)
- Java多线程编程中，如何优雅地终止线程？ (liqianqian1116, 2023-5-12)
标题搜索
我的存档
数据统计
- 访问量: 245688
- 日志数: 939
- 建立时间: 2020-08-11
- 更新时间: 2024-04-12
