JDK1.8-Stream API使用

一、引言

首先，Java8的Stream是对集合对象操作的API，它专注于对集合对象进行各种非常便利，高效的聚合操作或者大批量操作，从而减少代码的复杂度。借助于lambda表达式，极大的提高编程效率和程序可读性。并且Stream支持串行和并行两种模式，使我们无需编写太多代码，就可以很方便的写出高性能的并发程序。

二、Stream结构及构建

public interface Stream<T> extends BaseStream<T, Stream<T>>
public interface BaseStream<T, S extends BaseStream<T, S>>
    extends AutoCloseable { {

可以看到，Stream继承自BaseStream接口，而BaseStream又继承自AutoCloseable接口，顾名思义，AutoCloseable负责流的自动关闭。

我们这里来了解下生成Stream的几种常用方式：

// 1. 借助Stream的of方法
Stream stream = Stream.of("a", "b", "c");
String [] strArray = new String[] {"a", "b", "c"};
// 2. 通过数组生成Stream
stream = Stream.of(strArray);
stream = Arrays.stream(strArray);
// 3. 通过集合来生成Stream
List<String> list = Arrays.asList(strArray);
stream = list.stream(); 

而对于基础数值类型，目前提供了三种对应的包装类型Stream：IntStream，LongStream，DoubleStrem，当然我们也可以使用 Stream<Integer>、Stream<Long>、Stream<Double>，但是 boxing 和 unboxing 会很耗时，所以特别为这三种基本数值型提供了对应的 Stream。

三、Stream使用

1.先说下Stream的类型，Stream一般情况下包含了两个类型：中间操作(Intermediate)和结束操作(Terminal)：

• Intermediate，所谓的中间操作，就是说每次调用做一些处理之后会返回一个新的Stream，这类操作都是惰性的，也就是说并没有真正开始流的遍历。这些操作包括：map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel等；
• Terminal，一个Stream只能执行一次结束操作，而且只能是最后一个操作，执行terminal之后，Stream被消费掉了，并且产生了一个结果，这些操作包括：forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny等；

再简单说下Stream流的特点，Stream其实有点类似于迭代器，每个Stream只能操作一次，操作过之后就不能再操作该对象了，也就是一种单向的，不可重复操作的对象。

 

2. map方法

该方法的作用就是将input Stream的每一个元素，按照一定规则处理之后，映射成output Stream的另一个元素，相当于一对一的输入输出，平时的时候该方式使用较多。比如我们将字符串数组中所有的对象转为大写：

List<String> list = Arrays.asList("stream", "map");
Stream<String> stream = list.stream();
List<String> newList = stream.map(input -> input.toUpperCase()).collect(Collectors.toList());

 因为Stream只能使用一次，如果我们再操作的话就是抛出异常：

List<String> newList = stream.map(input -> input.toUpperCase()).collect(Collectors.toList());
newList = stream.map(input -> input.toLowerCase()).collect(Collectors.toList());

 异常结果：

Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
    at java.util.stream.AbstractPipeline.<init>(AbstractPipeline.java:203)
    at java.util.stream.ReferencePipeline.<init>(ReferencePipeline.java:94)
    at java.util.stream.ReferencePipeline$StatelessOp.<init>(ReferencePipeline.java:618)
    at java.util.stream.ReferencePipeline$3.<init>(ReferencePipeline.java:187)
    at java.util.stream.ReferencePipeline.map(ReferencePipeline.java:186)

 3. mapToInt/mapToLong/mapToDouble方法

顾名思义，这就是将对应的Stream转为IntStream，LongStream，DoubleStream

List<Integer> list = Arrays.asList(100, 200);
IntStream intStream = list.stream().mapToInt(input -> input);

 4. flatMap方法

前面说过的map方法是一对一的输入输出，而flatMap方法则是一种一对多的映射关系。

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

 结果：

[1,2,3,4,5,6]

 flatMap 是对input Stream 中的层级进行结构扁平化，就是将最底层元素抽出来放到一起，最终 output 的新 Stream 里面都是单个的数字。我们再来简单看下map方法的对应实现：

// inputStream不变
Stream<Stream<Integer>> stream = inputStream.map(childList -> childList.stream());
List<List<Integer>> list = stream.map(input -> input.collect(Collectors.toList())).collect(Collectors.toList());
System.out.println(list);

 结果：

[[1], [2, 3], [4, 5, 6]]

 从这里可以大致看出它们的区别，对于flatMap来说，它的输入输出大致如下：

{{1,2}，{3,4}，{5,6}}  -> flatMap  -> {1,2,3,4,5,6}

 而对map方法来说，则是：

{{1,2}，{3,4}，{5,6}}  -> map -> {1,2}, {3,4},{5,6}

 5. filter方法

该方法用于对Stream中的元素按照某些条件进行过滤，过滤后的元素生成一个新的元素，比如过滤数组中的偶数：

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

 结果：

2 4 6 

 6. foreach方法

类似于for循环，用于遍历Stream中的每个元素，比较简单，可能需要注意的是，forEach 不能修改自己包含的本地变量值，也不能使用 break/return 之类的关键字提前结束循环：

Stream<String> stream = Stream.of("hello", "world");
// 方式1
stream.forEach(num -> System.out.print(num));
// 方式2
stream.forEach(System.out::print);

 7. findFirst

返回Stream对象的第一个元素，由于返回的是Optional，所以返回的值有可能为空：

Stream<String> stream = Stream.of("hello", "world");
Optional<String> optional = stream.findFirst();
String name = optional.map(String::toLowerCase).orElse("");
System.out.println(name);

 Optional是jdk8提供的一种用于优雅的解决 NullPointExecption 的方式，等再写文章我们来学习一下。

8. reduce方法

这个方法的作用主要是把Stream中的元素组合起来，比如说字符串拼接，数值类型的求和等都是特殊的reduce操作，并且我们可以根据重载方法选择是否有初始值。

// 字符串连接，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);
// 求和的另一种形式
int sum = Stream.of(1, 2, 3, 4).reduce(0, (a,b) -> a+b);
// 求和，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);

上面代码例如第一个示例的 reduce()，第一个参数（空白字符）即为起始值，第二个参数（String::concat）为 BinaryOperator，这类有起始值的 reduce() 都返回具体的对象。而对于第四个示例没有起始值的 reduce()，返回的是 Optional，请留意这个区别。

9. limit/skip方法

limit方法用于返回Stream元素的前n个元素，而skip方法是跳过前n个元素返回剩余的元素：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
list.stream().limit(8).forEach(System.out::print);
System.out.println();
list.stream().limit(8).skip(3).forEach(System.out::print);

 结果：

12345678
45678

 10. sorted

 sorted方法是用于对Stream元素进行排序的，我们可以按照默认的自然排序规则进行排序， 也可以指定具体的比较器来进行排序：

Stream<T> sorted();
Stream<T> sorted(Comparator<? super T> comparator);

 Stream的sorted方法比数组的排序更强之处在于，你可以首先对 Stream 进行各类 map、filter、limit、skip操作之后再进行排序：

List<Integer> list = Arrays.asList(5, 7, 1, 4, 2, 6, 3, 8, 9, 10);
list.stream().limit(5).sorted().forEach(System.out::print);
System.out.println();
list.stream().limit(5).sorted(Comparator.reverseOrder()).forEach(System.out::print);

 结果：

12457
75421

 11. min/max/distinct方法　

min 和 max 的功能也可以通过对 Stream 元素先排序，再 findFirst 来实现，但前者的性能会更好，为 O(n)，而 sorted 的成本是 O(n log n)。我们来看一下获取最小值的方式：

List<Integer> list = Arrays.asList(5, 7, 1, 4, 2, 6, 3, 8, 9, 10);
// 通过Stream的min方法
Integer min2 = list.stream().min(Comparator.naturalOrder()).get();
// 通过IntStrem的min方法
Integer min1 = list.stream().mapToInt(input -> input).min().getAsInt();

 而distinct方法是用于过滤重复数据的：

List<Integer> list = Arrays.asList(5, 7, 1, 7, 2, 6, 3, 9, 9, 10);
list.stream().distinct().forEach(System.out::print);

 结果：

571263910

12. allMatch/anyMatch/noneMatch方法

• allMatch， 对Stream中的所有元素进行判断，全部满足条件的时候返回true，只要有一个不符合条件就返回false；
• anyMatch，Stream中只要有一个满足条件，就返回true；
• noneMatch，Stream中没有一个元素满足条件，这时返回true；

List<Integer> list = Arrays.asList(5, 7, 1, 7, 2, 6, 3, 9, 9, 10);
boolean isAllRight = list.stream().allMatch(input -> (input > 0));
boolean isAnyRight = list.stream().anyMatch(input -> (input > 2));
boolean isNoneRight = list.stream().noneMatch(input -> (input < 0));
System.out.println("isAllRight:" + isAllRight + " isAnyRight:" + isAnyRight + " isNoneRight:" + isNoneRight);

 结果：

isAllRight:true isAnyRight:true isNoneRight:true

 13. peek方法

peek方法，会生成一个包含原Stream的所有元素的新Stream，同时会提供一个消费函数（Consumer实例），新Stream每个元素被消费的时候都会执行给定的消费函数。比如说foreach方法是一个terminal 操作，执行之后，Stream就消费掉了，我们无法对一个Stream进行两次操作，而peek方法作为intermediate 操作，则可以达到类似的目的：

Stream.of("one", "two", "three", "four")
    .filter(e -> e.length() > 3)
    .peek(e -> System.out.println("Filtered value: " + e))
    .map(String::toUpperCase)
    .peek(e -> System.out.println("Mapped value: " + e))
    .collect(Collectors.toList());

 结果：

Filtered value: three
Mapped value: THREE
Filtered value: four
Mapped value: FOUR

如上，我们可以在遍历列表的时候，先打印字符串，再将该字符串转成大写再打印出来。

另外，根据API的说明，该方法主要用于调试，方便debug查看Stream内进行处理的每个元素。

14. forEachOrdered方法

forEachOrdered方法和 forEach 方法功能一样，都是用于遍历Stream，不同的地方在于并行流的处理上。并行的时候 forEach 方法为了效率，它的顺序和Stream元素的顺序不一定完全一样，而forEachOrdered 方法的顺序则是和Stream元素的顺序是一样的。

List<String> list = Arrays.asList("x", "y", "z");

list.parallelStream().forEach(x -> System.out.print(" " + x));
System.out.println();
list.parallelStream().forEachOrdered(x -> System.out.print(" " + x));
System.out.println();

//输出的顺序不一定（效率更高）
Stream.of("AAA", "BBB", "CCC").parallel().forEach(s -> System.out.print(" " + s));
System.out.println();
//输出的顺序与元素的顺序严格一致
Stream.of("AAA", "BBB", "CCC").parallel().forEachOrdered(s -> System.out.print(" " + s));

 结果：

 y x z
 x y z
 BBB CCC AAA
 AAA BBB CCC

 15. toArray方法

这个方法比较简单，就是返回对应的数组，该方法默认是返回Object数组，不过我们可以使用它的重载方法返回对应格式的数组：

Object[] toArray();
<A> A[] toArray(IntFunction<A[]> generator);

对应例子：

List<String> list = Arrays.asList("x", "y", "z");
Object[] objects = list.stream().toArray();
Integer[] arrays = list.stream().toArray(Integer[]::new);

16. count方法 

count方法表示获取Stream流中元素的数量，返回long类型：

// 打印 4 
long num = Stream.of(1, 2, 3, 4).count();
// 打印 3
long num = Stream.of(1, 2, 3, 4).limit(3).count();

 17. findAny方法

findAny方法表示从流中随便选择一个元素，该方法返回的值是不稳定的：

Integer num = Stream.of(1, 2, 3, 4).findAny().get();

18. collect方法

collect方法我们前面已经接触过，有两个方法，我们先看一下简单的那个：

<R, A> R collect(Collector<? super T, A, R> collector);

在前文中，我们使用map方法对流进行处理之后，返回的还是一个Stream，而此时我们是无法我们的集合操作的，这时候就需要将流重新转换为集合框架中对应的集合，那么这时候我们就可以通过该方法来实现：

List<String> list = Arrays.asList("hello", "world").stream().collect(Collectors.toList());

该方法接收一个Collector类型的参数，但幸运的是Java8给我们提供了Collector的工具类：Collectors，这其中已经定义了一些静态工厂方法，比如Collectors.toCollection() 生成集合，Collectors.toList()生成List，Collectors.toSet() 生成Set等，Collectors是个很好的工具类，封装了许多操作，后续我们再来介绍。

接下来，再简单看下该方法的另一个重载方法：

<R> R collect(Supplier<R> supplier,
      BiConsumer<R, ? super T> accumulator,
      BiConsumer<R, R> combiner);

该方法比较复杂，我们先简单分析下，等以后如果用到了，再来仔细研究。该方法有三个参数：Supplier supplier是一个工厂函数，用来生成一个新的容器；BiConsumer accumulator也是一个函数，用来把Stream中的元素添加到结果容器中；BiConsumer combiner还是一个函数，用来把中间状态的多个结果容器合并成为一个（并发的时候会用到）。来简单看一下例子吧：

List<Integer> nums = Arrays.asList(1, 1, null, 2, 3, 4, null, 5, 6, 7, 8, 9, 10);
List<Integer> numsWithoutNull = nums.stream().filter(num -> num != null).
        collect(() -> new ArrayList<Integer>(),
                (list, item) -> list.add(item),
                (list1, list2) -> list1.addAll(list2));

 使用方法引用来优化下该例子：

List<Integer> nums = Arrays.asList(1, 1, null, 2, 3, 4, null, 5, 6, 7, 8, 9, 10);
List<Integer> numsWithoutNull = nums.stream().filter(num -> num != null).
        collect(ArrayList::new, ArrayList::add, ArrayList::addAll);

 接下来，说下该方法：该方法是将一个Integer类型的List，先过滤掉为null的元素，然后把剩下的元素放到新的List中。再来看一下这些参数：

1. 第一个函数生成一个新的ArrayList实例；
2. 第二个函数接受两个参数，第一个是前面生成的ArrayList对象，第二个是stream中包含的元素，函数体就是把stream中的元素加入ArrayList对象中。第二个函数被反复调用直到原stream的元素被消费毕；
3. 第三个函数也是接受两个参数，这两个都是ArrayList类型的，函数体就是把第二个ArrayList全部加入到第一个中；

这么来看，这个方法是有点复杂，并且单看这个例子的话，是完全可以使用上面那个重载方法然后借助Collectors.toList来实现的。对这个方法的了解就到这了，等以后如果用到了，再来更新。

接下来是Stream的静态方法，这些静态方法目的都是为了创建Stream流。

1. of方法

Stream的of方法用来构建有序的Stream对象，有两个方法，提供单个对象及多个对象的构建：

public static<T> Stream<T> of(T t)
public static<T> Stream<T> of(T... values) 

比如说：

Stream stream = Stream.of("a");
IntStream intStream= IntStream.of(1, 2, 3);

 2. builder方法

通过使用Stream.builder方法生成Builder对象，Builder对象是Stream的可变构造器，也称为流构造器，该对象允许单独生成元素并添加到构造器，然后来生成流，来避免使用ArrayList作为临时缓冲区产生的复制开销。流构建器有一个生命周期，它从一个构建阶段开始，在这个阶段中可以添加元素，然后过渡到一个构建阶段，在这个阶段之后，可能不会添加元素。构建阶段从调用build()方法开始，该方法创建一个有序流，其元素是按照添加到流构建器的顺序添加到流构建器的元素。

Stream.Builder builder = Stream.builder();
builder.accept("hello");
builder.add("world");
Stream stream = builder.build();
stream.forEach(input -> System.out.print(input + " "));

//或者
Stream<String> streamBuilder = Stream.<String>builder().add("hello").add("world").build();

 结果：

hello world 

3. empty方法

创建一个不包含任何元素的有序的Stream流：

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

 4. iterate方法

Stream的iterate方法和reduce方法有点像，接受一个种子值，和一个 UnaryOperator（例如 f），然后种子值成为 Stream 的第一个元素，f(seed) 为第二个，f(f(seed)) 第三个，以此类推：

// 比如生成等差数列 0 3 6 9 12 15 18 21 24 27 
Stream.iterate(0, n -> n + 3).limit(10). forEach(x -> System.out.print(x + " "));

 同样，iterate也是无限的，在进行iterate的时候，必须要有limit这样的操作来限制大小，但iterate生成的Stream是连续且有序的。

5. generate方法

通过实现 Supplier 接口，我们可以自己来控制流的生成，这种情形通常用于随机数、常量的 Stream，把 Supplier 实例传递给 Stream.generate() ，这种生成的 Stream流是无限的，所以我们必须使用limit等方法来限制Stream的大小，并且通过generate方法生成的Stream是无序的；

// 生成10个随机数
Stream.generate(new Random()::nextInt).limit(10).forEach(System.out::println);
//另外一种方式
IntStream.generate(() -> (int) (System.nanoTime() % 100)).limit(10).forEach(System.out::println);

6. concat方法

返回两个Stream流连接的流：

public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) 

Stream<Integer> stream1 = Stream.of(1, 2, 3, 4);
Stream<Integer> stream2 = Stream.of(5, 6, 7, 8);
Stream.concat(stream1, stream2).forEach(System.out::print);

四、IntStream LongStream DoubleStream补充

因为这三个Stream中的操作属于数值操作，所以它们中有些方法Stream中并没有，我们也来简单介绍下。由于这三个Stream都差不多，我们就以IntStream来进行举例。

1. sum/min/max/count/average方法
min，max，count方法Stream中都有，只不过在IntStream中这些方法的参数和返回值可能和Stream方法的返回值有稍许的不同，不过功能是一样的。

// 计算min
IntStream.of(1, 2, 3, 4).min().getAsInt();
IntStream.of(1, 2, 3, 4).reduce(0, Integer::min);

// 计算max
IntStream.of(1, 2, 3, 4).max().getAsInt();
IntStream.of(1, 2, 3, 4).reduce(0, Integer::max);

sum方法的话，就是用于计算Stream中元素值的和，同样也可也使用reduce方法来代替：

int sum = IntStream.of(1, 2, 3, 4).sum();
int sum = IntStream.of(1, 2, 3, 4).reduce(0, Integer::sum);

而average方法是用于计算平均值的，返回的是OptionalDouble类型：

// 计算平均值
double average = IntStream.of(1, 2, 3, 4).average().getAsDouble();

 2. summaryStatistics方法

该方法用于获取Stream流的各项汇总数据，我们直接看例子就明白了：

// 各种计算值的汇总数据
IntSummaryStatistics summaryStatistics = IntStream.of(1, 2, 3, 4).summaryStatistics();
// 平均值，元素个数，最大值，最小值，总和
System.out.println(summaryStatistics.getAverage());
System.out.println(summaryStatistics.getCount());
System.out.println(summaryStatistics.getMax());
System.out.println(summaryStatistics.getMin());
System.out.println(summaryStatistics.getSum());

3. asLongStream/asDoubleStream方法
这两个方法比较简单，就是转为对应的LongStream流和DoubleStream流。

4. boxed方法
基础类型的装箱操作，比如将int类型装箱称为Integer类型：

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

5. range方法

range方法是IntStream中的静态方法，用于构建某段范围的IntStream流：

public static IntStream range(int startInclusive, int endExclusive) 

创建的Stream流包含开始值 startInclusive(inclusive)，但不包含结束值 endExclusive(exclusive)：

IntStream intStream = IntStream.range(1, 5);
// 1 2 3 4 
intStream.forEach(x -> System.out.print(x + " "));

6. rangeClosed方法

rangeClosed方法和range方法唯一的不同就是，创建的Stream流既包含开始值，又包含结束值，这点从参数命名上就可以知道。不得不说，该方法参数的命名很规范，值得我们学习：

public static IntStream rangeClosed(int startInclusive, int endInclusive)

 对应的实例：

IntStream intStream = IntStream.rangeClosed(1, 5);
// 1 2 3 4 5 
intStream.forEach(x -> System.out.print(x + " "));

五、BaseStream中的方法

上面忘了说了，BaseStream作为Stream的底层接口，有几个方法值得了解一下：

1. parallel方法

返回一个并行的且等效流，可能返回该流本身，因为该Stream已经是并行的，或者该Stream的底层状态被修改为了并行。

2. isParallel方法

判断该Stream是否是并行的：

IntStream intStream = IntStream.rangeClosed(1, 5);
// false
boolean isParallel = intStream.isParallel();
// true
isParallel = intStream.parallel().isParallel();

3. iterator/spliterator方法

这两个方法就比较简单了，iterator就是返回迭代器对象，而spliterator则是返回一个并行的迭代器对象；

4. unordered方法

  返回一个无序的等效的Stream，可能返回的是Stream本身，因为该Stream已经是无序的，或者该Stream的底层状态被修改为了无序。当不考虑流的顺序时，可以使用无序的Stream来进行操作，这样可以加快一些方法的执行速度，提高一些性能，一般用于并行的时候。