当前位置： 首页 > Java > Java 8 Stream API

Java 8 Stream API

 www.zhblog.net  2020-05-28

Java 8 中的 Stream 被定义为源的一系列元素，它们可以聚合操作。这里的源可以是Collections或Arrays，为源提供元素。Stream 会保持元素在源中的顺序，聚合操作或批量操作是在为每个元素进行相同的操作。java 8 中的 Stream 被设计为链式调用，它的大多数方法返回的是Stream本身。这种方式也被称为管道。


1. Java Stream VS Collection

我们平时在网站在线看视频，当开始观看时，视频文件的一部分会加载到我们的电脑，然后进行播放。你不需要在观看前下载完整的视频文件，这就是流。

Collection是内存中的数据结构，Collection中的每个元素在加载到Collection之前都完成计算的操作。而流的结构是固定的，它的元素是按需计算。这具有很大的优势，数据仅在用户需要时，才会提供相应的数据，这类似生产者 - 消费者的关系。

在Java中，java.util.Stream表示流，它可以进行一次或多少操作。流的操作分两种：一种是中间操作返回自身；另一种是返回一个明确类型值的终端操作，所有我们可以链式调用多个方法。流是在源上创建的，如java.util.Collection中的list、set（map不支持流操作）。流操作可以顺序执行，也可以并行执行。

流的特征：

不是一个数据结构

支持lambdas

不支持索引访问

可以很容易的作为列表和数组输出

支持延迟操作

可并行操作


2.创建流的不同方式

下面是常用的几种：


2.1 Stream.of(val1, val2, val3......)

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

stream.forEach(p -> System.out.println(p));


2.2 Stream.of(arrayOfElements)

Stream<Integer> stream = Stream.of(new Integer[]{1, 2, 3, 4, 5, 6});

stream.forEach(p -> System.out.println(p));


2.3 List.stream()

List<Integer> list = new ArrayList<>();

for (int i = 0; i < 10; i++) {

    list.add(i);

}

Stream<Integer> stream = list.stream();

stream.forEach(p -> System.out.println(p));


2.4 Stream.generate() or Stream.iterate()

Stream<Date> streamGenerate = Stream.generate(() -> {return new Date();});

streamGenerate.forEach(p -> System.out.println(p));

Stream<Integer> streamIterate = Stream.iterate(1, n -> n + 1);

streamIterate.forEach(p -> System.out.println(p));


2.5 String chars or String tokens

IntStream stream = "123456_abcdef".chars();

stream.forEach(p -> System.out.println(p));

// or

Stream<String> stream = Stream.of("A$B$C".split("\\$"));

stream.forEach(p -> System.out.println(p));


像Stream.Buider和一些中间方法返回流的，就不全列了。


3. 将流转为集合

流转集合其实是将流的所有数据全部放到集合中。


3.1 Stream 转为 List - Stream.collect(Collectors.toList())

List<Integer> list = new ArrayList<>();

for (int i = 0; i < 10; i++) {

    list.add(i);

}

Stream<Integer> stream = list.stream();

List<Integer> evenNumbers = stream.filter(i -> i % 2 == 0).collect(Collectors.toList());

System.out.println(evenNumbers);


3.2 Stream 转为 Array - Stream.toArray(EntryType::new)

List<Integer> list = new ArrayList<>();

for (int i = 0; i < 10; i++) {

    list.add(i);

}

Stream<Integer> stream = list.stream();

Integer[] evenNumbers = stream.filter(i -> i % 2 == 0).toArray(Integer[]::new);

Stream.of(evenNumbers).forEach(p -> System.out.println(p));


还有很多其它的方式将stream转为set、map，这些方式都在Collectors类中。



4.流的核心操作

流的接口中有一系列方法，这里列出一些重要的操作方法。

首先构建一个列表，下面例子都基于这个列表：

List<String> memberNames = new ArrayList<>();

memberNames.add("Amitabh");

memberNames.add("Shekhar");

memberNames.add("Aman");

memberNames.add("Rahul");

memberNames.add("Shahrukh");

memberNames.add("Salman");

memberNames.add("Yana");

memberNames.add("Lokesh");


4.1 中间方法

中间方法返回它自身，可以链式调用。


4.1.1 Stream.filter()

filter方法通过给定的判定去过滤Stream中的元素

memberNames.stream().filter(p -> p.startsWith("A")).forEach(System.out::println);


输出：

Amitabh

Aman


4.1.2 Stream.map()

将Stream中的每个元素应用map中给定的方法

memberNames.stream().filter(p -> p.startsWith("A")).map(String::toUpperCase).forEach(System.out::println);


输出：

AMITABH

AMAN


4.1.3 Stream.sorted()

返回Stream排序的视图，默认自然序，除非自定义排序。

memberNames.stream().sorted().map(String::toUpperCase).forEach(System.out::println);


注意：sorted方法仅仅创建Stream的排序视图，不会更改集合的原始顺序。


4.2 终端方法

终端方法返回具体的类型结果，而不是流本身


4.2.1 Stream.collect()

方法从Stream中接收元素保存到参数中指定的集合

List<String> list = memberNames.stream().sorted().map(String::toUpperCase).collect(Collectors.toList());

System.out.println(list);


结果：

[AMAN, AMITABH, LOKESH, RAHUL, SALMAN, SHAHRUKH, SHEKHAR, YANA]

         

4.2.2 Stream.match()

match有多种判定方式，结果返回一个boolean值

boolean m1 = memberNames.stream().anyMatch(p -> p.startsWith("A")); // 包含

boolean m2 = memberNames.stream().allMatch(p -> p.startsWith("A")); // 全部

boolean m3 = memberNames.stream().noneMatch(p -> p.startsWith("A")); // 不包含



System.out.println(m1);

System.out.println(m2);

System.out.println(m3);


结果：

true

false

false

         

4.2.3 Stream.count()

方法返回一个long数值，计数Stream中元素的数量

long count = memberNames.stream().filter(p -> p.startsWith("A")).count();

System.out.println(count); // 2


4.2.4 Stream.reduce()

方法会减少流的元素，返回最后值

memberNames.stream().reduce((s1, s2) -> s1 + "#" + s2).ifPresent(p -> System.out.println(p));


计算数字1-10的和

Integer[] numbers = new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

Stream.of(numbers).reduce((n1, n2) -> n1 + n2).ifPresent(p -> System.out.println(p));


5. Stream 短路操作

通常流会为集合中所有元素进行操作，但有时我们希望匹配某元素后停止后续操作。通常在外部循环，使用if-else即可。而在流的内部循环中，有明确的方法可以做到这点。


5.1 Stream.anyMatch()

一旦满足给定的判断条件，就立即返回，不再处理后续元素

boolean match = memberNames.stream().anyMatch(p -> p.startsWith("A"));

System.out.println(match); // true


5.2 Stream.findFirst()

它将从流中返回第一个元素，不处理后续元素。

String name = memberNames.stream().filter(p -> p.startsWith("S")).findFirst().get();

System.out.println(name);  # Shekhar


6. Java Stream 的并行

多线程可以提升执行的性能，但编写健壮的多线程程序不易。Stream提供了健壮、容易编写的并行方法，只需要将顺序流stream替换成并行流parallelStream。上面所有例子中，你用parallelStream()替换stream()，就开启了并行。

List<Integer> list = new ArrayList<>();

for (int i = 0; i < 20; i++) {

    list.add(i);

}

list.parallelStream().filter(p -> p % 2 == 0).forEach(p -> System.out.println(p));


结果

6

2

12

18

4

8

0

10

16

14


并行性可能带来不确定性和不期望的资源竞争。


 

展开阅读全文