龙空技术网

Java8 Stream流API使用简介

JAVA微学堂 267

前言:

目前兄弟们对“java开发api接口”大概比较注意,朋友们都需要了解一些“java开发api接口”的相关资讯。那么小编也在网摘上汇集了一些对于“java开发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开发api接口