JDK1.8新特性——Stream API

摘要：本文主要学习了JDK1.8的新特性中有关Stream API的使用。

部分内容来自以下博客：

https://blog.csdn.net/icarusliu/article/details/79495534

概述

是什么

Stream API（java.util.stream）把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

Stream是JDK1.8中处理集合的关键抽象概念，它可以指定对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用Stream API来并行执行操作。简言之，Stream API提供了一种高效且易于使用的处理数据的方式。

操作方式

JDK1.8通过内部迭代来实现对流的处理，一个流式处理可以分为三个部分：转换成流、中间操作、终止操作。

转换成流：将原始数据转换成一个流对象，以便进行后续操作。

中间操作：将原始的Stream转换成另外一个Stream，如filter返回的是过滤后的Stream。

终止操作：产生的是一个结果或者其它的复合操作，如count或者forEach操作。

转换成流

创建空的Stream对象

 Stream stream = Stream.empty();

通过集合类中的stream()方法或者parallelStream()方法创建

 List<String> list = Arrays.asList("a", "b", "c", "d");

 Stream stream = list.stream();// 获取串行的Stream对象

 Stream parallelStream = list.parallelStream();// 获取并行的Stream对象

通过数组工具类Arrays的stream()方法创建

 String[] arr = {"a", "b", "c", "d"};

 Stream<String> stream = Arrays.stream(arr);

通过Stream中的of()方法创建

 Stream stream = Stream.of("test");

 Stream stream = Stream.of("a", "b", "c");

通过Stream中的iterate()方法创建有序的Stream

 public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f);

通过Stream中的generate()方法创建无序的Stream

 public static<T> Stream<T> generate(Supplier<T> s);

中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何得处理，而终止操作时一次性全部处理，称为“惰性求值”。

过滤：filter

定义如下：

对Stream对象按指定的Predicate进行过滤，返回的Stream对象中仅包含未被过滤的元素。

 Stream<T> filter(Predicate<? super T> predicate);

代码如下：

 public static void main(String[] args) {

     Stream<Integer> stream = Stream.of(1, 9, 5, 3, 7);

     // 同一个流不能用两遍。

     Stream<Integer> streamFilter = stream.filter(new Predicate<Integer>() {

         // 使用了匿名类，重写了test()方法。

         @Override

         public boolean test(Integer i) {

             if (i > 5) {

                 return true;

             }

             return false;

         }

     });

     // 为了看到过滤后的效果，使用了终止操作forEach()进行打印。

     streamFilter.forEach(e -> System.out.println(e));

 }

运行结果如下：

 9

 7

截取：limit

定义如下：

获取指定的前几个元素，组成新的Stream对象返回。

 Stream<T> limit(long maxSize);

代码如下：

 public static void main(String[] args) {

     Stream<Integer> stream = Stream.of(1, 9, 5, 3, 7).limit(2);

     // 为了看到过滤后的效果，使用了终止操作forEach()进行打印。

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

 }

运行结果如下：

 1

 9

跳过：skip

定义如下：

跳过指定的前几个元素，使用剩下的元素组成新的Stream返回。

 Stream<T> skip(long n);

代码如下：

 public static void main(String[] args) {

     Stream<Integer> stream = Stream.of(1, 9, 5, 3, 7).skip(2);

     // 为了看到过滤后的效果，使用了终止操作forEach()进行打印。

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

 }

运行结果如下：

去重：distinct

定义如下：

调用元素的equals()方法比较，返回一个去重后的Stream对象。

 Stream<T> distinct();

代码如下：

 public static void main(String[] args) {

     Stream<Integer> stream = Stream.of(1, 9, 5, 3, 7, 9, 3).distinct();

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

 }

运行结果如下：

排序：sorted

定义如下：

传入一个比较器，返回排序后的Stream对象。

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

代码如下：

 public static void main(String[] args) {

     Stream<Integer> stream = Stream.of(1, 9, 5, 3, 7).sorted((m, n) -> m - n);

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

 }

运行结果如下：

映射（一对一）：map

定义如下：

将元素转换成其他形式或者提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。

 <R> Stream<R> map(Function<? super T, ? extends R> mapper);

代码如下：

 public static void main(String[] args) {

     Stream<String> streamStr = Stream.of("aa", "aaa", "a", "aaaaa", "aaaa");

     Stream<Integer> streamInt = streamStr.map(e -> e.length());

     streamInt.forEach(e -> System.out.println(e));

 }

运行结果如下：

散射（一对多）：flatMap

定义如下：

对原Stream中的所有元素进行操作，每个元素会有一个或者多个结果，然后将返回的所有元素组合成一个统一的Stream并返回。

 <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

代码如下：

 public static void main(String[] args) {

     List<String> list = Arrays.asList("aa", "bb");

     list.stream().flatMap((e) -> Demo.filterCharacter(e)).forEach(e -> System.out.println(e));

 }

 public static Stream<Character> filterCharacter(String str){

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

     for (Character ch : str.toCharArray()) {

         list.add(ch);

     }

     return list.stream();

 }

运行结果如下：

 a

 a

 b

 b

终止操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List，Integer，甚至是void。

检查是否匹配所有元素：allMatch

定义如下：

如果所有元素都满足条件，那么返回true，否则返回false。

 boolean allMatch(Predicate<? super T> predicate);

代码如下：

 public static void main(String[] args) {

     boolean match = Stream.of("aa11", "bb11", "cc11").allMatch(e -> e.contains("11"));

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

 }

检查是否至少匹配一个元素：anyMatch

定义如下：

如果至少有一个元素满足条件，就返回true，否则返回false。

 boolean anyMatch(Predicate<? super T> predicate);

代码如下：

 public static void main(String[] args) {

     boolean match = Stream.of("aa11", "bb11", "cc11").anyMatch(e -> e.contains("aa"));

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

 }

检查是否没有匹配的元素：noneMatch

如果所有元素都不满足条件，返回true，否则返回false。

定义如下：

 boolean noneMatch(Predicate<? super T> predicate);

代码如下：

 public static void main(String[] args) {

     boolean match = Stream.of("aa11", "bb11", "cc11").noneMatch(e -> e.contains("dd"));

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

 }

返回第一个元素：findFirst

定义如下：

返回遇到的第一个元素。

 Optional<T> findFirst();

代码如下：

 public static void main(String[] args) {

     Optional<String> find = Stream.of("aa11", "bb11", "cc11").findFirst();

     System.out.println(find);// Optional[aa11]

 }

返回任意一个元素：findAny

定义如下：

返回处理最快的那个元素。

 Optional<T> findAny();

代码如下：

 public static void main(String[] args) {

     Optional<String> find = Stream.of("aa11", "bb11", "cc11").findAny();

     System.out.println(find);// Optional[aa11]

 }

返回元素个数：count

定义如下：

 long count();

代码如下：

 public static void main(String[] args) {

     long count = Stream.of("aa11", "bb11", "cc11").count();

     System.out.println(count);//

 }

返回元素最大值：max

定义如下：

 Optional<T> max(Comparator<? super T> comparator);

代码如下：

 public static void main(String[] args) {

     Optional<String> max = Stream.of("aa11", "bb11", "cc11").max((m, n) -> m.hashCode() - n.hashCode());

     System.out.println(max);// Optional[cc11]

 }

返回元素最小值：min

定义如下：

 Optional<T> min(Comparator<? super T> comparator);

代码如下：

 public static void main(String[] args) {

     Optional<String> max = Stream.of("aa11", "bb11", "cc11").min((m, n) -> m.hashCode() - n.hashCode());

     System.out.println(max);// Optional[aa11]

 }

规约元素：reduce

定义如下：

可以将流中元素反复结合起来，得到一个值，包含T类型的identity，返回T类型的值。

 T reduce(T identity, BinaryOperator<T> accumulator);

可以将流中元素反复结合起来，得到一个值，返回Optional类型的值。

 Optional<T> reduce(BinaryOperator<T> accumulator);

代码如下：

 public static void main(String[] args) {

     List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

     Integer sumWith0 = list.stream().reduce(0, (x, y) -> x + y);

     System.out.println(sumWith0);//

     Integer sumWith5 = list.stream().reduce(5, (x, y) -> x + y);

     System.out.println(sumWith5);//

     Optional<Integer> sum = list.stream().reduce((x, y) -> x + y);

     System.out.println(sum);// Optional[15]

 }

收集元素：collect

定义如下：

将流转换为其他形式，接收一个Collector接口的实现，用于给Stream中元素做汇总的方法。

Collector接口中方法的实现决定了如何对流执行收集操作（如收集到List、Set、Map）。但是Collectors实用类提供了很多静态方法，可以方便地创建常见收集器实例。

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

代码如下：

 public static void main(String[] args) {

     List<Integer> list = Arrays.asList("aaa", "aa", "aaaaa", "a", "aaaaaa").stream().map(String::length).collect(Collectors.toList());

     list.forEach(System.out::println);

 }