JAVA8-Stream API

JAVA8-Stream API

只能以事先规定好的顺序被读取一次的数据的一个序列，称之为数据流。 —— Henzinger

Stream 特性

在JAVA8中，java.util.stream 中定义的一系列流API，是对 集合（Collection） 对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。java8中的 Stream 更多的是对集合的操作，和 java.io 包里的 InputStream 与 OutputStream 中的流是不一样的。

特性如下：

• 不保存数据
• 不修改数据源但会产生结果（或副作用）
• 流没有大小限制
• 流只能被访问一次，当需要再次访问时需要重新生成流

Stream 使用

当我们使用一个流的时候，通常包括三个基本步骤：

• 获取一个数据源（source）
• 数据转换
• 执行操作获取想要的结果

其中，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道。每次通过 Stream API 对集合和数组进行操作时，都需要先生成一个 Stream source。

Stream 创建

不同的对象有不同生成Stream的方式。主要如下：

• 从 Collection 和数组
  • Collection.stream()
  • Collection.parallelStream()
  • Arrays.stream(T array) or Stream.of()
• 从 BufferedReader
  • java.io.BufferedReader.lines()
• 静态工厂
  • java.util.stream.IntStream.range()
  • java.nio.file.Files.walk()
• 自己构建
  • java.util.Spliterator
• 其他
  • Random.ints()
  • BitSet.stream()
  • Pattern.splitAsStream(java.lang.CharSequence)
  • JarFile.stream()

示例：

// 1. Individual values
Stream stream = Stream.of("a", "b", "c");
// 2. Arrays
String [] strArray = new String[] {"a", "b", "c"};
stream = Stream.of(strArray);
stream = Arrays.stream(strArray);
// 3. Collections
List<String> list = Arrays.asList(strArray);
stream = list.stream();

由于基本数据类型的开箱和封箱过程特别耗时，所以提供了三种对应的包装类型Stream：

• IntStream
• LongStream
• DoubleStream

数值流的构造：

IntStream.of(new int[]{1, 2, 3});
IntStream.range(1, 3);
IntStream.rangeClosed(1, 3);

流的操作

将流创建成功之后，就需要对其进行操作，流的操作方式有两种：中间操作与末端操作

• Intermediate ：一个流可以后面跟随零个或多个 intermediate 操作。其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。这类操作都是惰性化的（lazy），就是说，仅仅调用到这类方法，并没有真正开始流的遍历。
  • 主要有： map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered 等操作
• Terminal ：一个流只能有一个 terminal 操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作。Terminal 操作的执行，才会真正开始流的遍历，并且会生成一个结果，或者一个 side effect（副作用）。
  • 主要有： forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator 等方式

还有一种操作被称为 short-circuiting。用以指：

• 对于一个 intermediate 操作，如果它接受的是一个无限大（infinite/unbounded）的 Stream，但返回一个有限的新 Stream。
• 对于一个 terminal 操作，如果它接受的是一个无限大的 Stream，但能在有限的时间计算出结果。
• 主要有 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit 等方式

当操作一个无限大的 Stream，而又希望在有限时间内完成操作，则在管道内拥有一个 short-circuiting 操作是必要非充分条件。

示例：

• map/flatMap

map的作用就是映射，将一个流映射成另一个流

String[] wordList = {"a","b","c"};
List<String> output = Arrays.stream(wordList).
    map(String::toUpperCase).
    collect(Collectors.toList());
//Arrays.stream(wordList) 构造一个流；
//map(String::toUpperCase) 中间操作，方法引用传入一个行为将流转换为另一个流
//collect(Collectors.toList()) 末端操作，将流转换为一个集合
System.out.println(output);

一对多的映射

Stream<List<Integer>> inputStream = Stream.of(
                Arrays.asList(1),
                Arrays.asList(2, 3),
                Arrays.asList(4, 5, 6)
        );
Stream<Integer> outputStream = inputStream.
                flatMap(Collection::stream);
System.out.println(outputStream.collect(Collectors.toList()));

输出结果：[1, 2, 3, 4, 5, 6]

• filter

filter 对原始 Stream 进行某项测试，通过测试的元素被留下来生成一个新 Stream。

Integer[] sixNums = {1, 2, 3, 4, 5, 6};
Integer[] evens = Stream.of(sixNums).filter(n -> n%2 == 0).toArray(Integer[]::new);
Stream.of(evens).forEach(System.out::print);

输出结果：246

• forEach

forEach 方法接收一个 Lambda 表达式，然后在 Stream 的每一个元素上执行该表达式。例如上面的 Integer[] sixNums = {1, 2, 3, 4, 5, 6};

• findFirst

这是一个 termimal 兼 short-circuiting 操作，它总是返回 Stream 的第一个元素，或者空。

这里比较重点的是它的返回值类型：Optional。作为一个容器，它可能含有某值，或者不包含。使用它的目的是尽可能避免 NullPointerException。

Stream 中的 findAny、max/min、reduce 等方法等返回 Optional 值。还有例如 IntStream.average() 返回 OptionalDouble 等等。

• reduce

reduce主要作用是把 Stream 元素组合起来。类似于不动点定理（增量），当给定一个不动点，再按照某种规则将前面 Stream 的元素逐一组合。也有没有不动点的情况，这时会把 Stream 的前面两个元素组合起来，返回的是 Optional。

示例：

// 字符串连接，concat = "ABCD"
String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat);
// 求最小值，minValue = -3.0
double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min);
// 求和，sumValue = 10, 有起始值
int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);
// 求和，sumValue = 10, 无起始值
sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
// 过滤，字符串连接，concat = "ace"
concat = Stream.of("a", "B", "c", "D", "e", "F").filter(x -> x.compareTo("Z") > 0).
                reduce("", String::concat);

• limit/skip

limit 返回 Stream 的前面 n 个元素；skip 则是扔掉前 n 个元素

List<String> persons = new ArrayList();
for (int i = 1; i <= 10000; i++) {
    persons.add("string" + i);
}
List<String>personList2=persons.stream().limit(10).skip(3).collect(Collectors.toList();
//limit(10)返回流的前10个元素，skip(3)则抛除前3个
System.out.println(personList2);

输出结果：

[string4, string5, string6, string7, string8, string9, string10]

• sorted

通过 sorted 对 Stream 的排序，它比数组的排序更强之处在于你可以首先对 Stream 进行各类 map、filter、limit、skip 甚至 distinct 来减少元素数量后，再排序，这能帮助程序明显缩短执行时间。

• Match

Stream 有三个 match 方法，从语义上说：

1. allMatch：Stream 中全部元素符合传入的 predicate，返回 true
2. anyMatch：Stream 中只要有一个元素符合传入的 predicate，返回 true
3. noneMatch：Stream 中没有一个元素符合传入的 predicate，返回 true

Stream的转换

对流进行操作后，需要转换成其他数据结构

// 1. Array
String[] strArray1 = stream.toArray(String[]::new);
// 2. Collection
List<String> list1 = stream.collect(Collectors.toList());
List<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new));
Set set1 = stream.collect(Collectors.toSet());
Stack stack1 = stream.collect(Collectors.toCollection(Stack::new));
// 3. String
String str = stream.collect(Collectors.joining()).toString();

扩展

Stream 还提供了 Stream.generate 方法自己创建流，通过实现Supplier接口，可以自己控制流的生成。把 Supplier 实例传递给 Stream.generate() 生成的 Stream，默认是串行（相对 parallel 而言）但无序的（相对 ordered 而言）。由于它是无限的，在管道中，必须利用 limit 之类的操作限制 Stream 大小。

//生成10个随机数
Random seed = new Random();
Supplier<Integer> random = seed::nextInt;
Stream.generate(random).limit(10).forEach(System.out::println);
//或者
IntStream.generate(() -> (int) (System.nanoTime() % 100)).
limit(10).forEach(System.out::println);