可能是Java Stream的最佳实践（一）——Stream是什么，有什么

“这是我参与8月更文挑战的第4天，活动详情查看：8月更文挑战”

从这一篇文章开始，我们会由浅入深，全面的学习stream API的最佳实践（结合我的使用经验），本想一篇写完，但写着写着发现需要写的内容太多了，所以分成一个系列慢慢来说。给大家分享我的经验的同时，也促使我复习每一个细节，大家共同进步。

Stream是什么

Java 8新增了一个API叫做Stream ，Stream的英文可以理解为流动的液体，可能很多人一听脑子里的第一印象就是流式计算，不自觉地就心生畏惧，感觉非常的高深莫测。其实这就是一个辅助处理集合数据的工具类，工具的更新必然带来的是生产力的提升，这里的生产力代表的就是整洁优雅的代码，更高的灵活度，更好的性能。相信各类的技术文章（包括博客和书籍）已经写过无数遍了。比如下面摘录《Java 8实战》关于流的描述：

流是Java API的新成员，它允许你以声明性方式处理数据集合（通过查询语句来表达，而不是临时编写一个实现）。就现在来说，你可以把它们看成遍历数据集的高级迭代器。此外，流还可以透明地并行处理，你无需写任何多线程代码了！

这段话的表述个人感觉类似于抓手、赋能、心智之类的PPT黑话，看着挺高级的，也能懂一些，但也不是很懂，反正如果对于不知道Stream的人，并不能建立直接的理解。

所以流到底是什么呢？是一个接口。让我们看看它的声明：

public interface Stream<T> extends BaseStream<T, Stream<T>> {
  
  Stream<T> filter(Predicate<? super T> predicate);
  
  <R> Stream<R> map(Function<? super T, ? extends R> mapper);
  
  void forEach(Consumer<? super T> action);
  ...
}

就是个接口，然后这个接口有一些抽象方法：filter，map，forEach等等。我们可以看到有些方法返回了新的Stream，有些直接是void。这个接口用来干什么用呢？处理集合数据。为什么这么说？看下面一个Collection接口的方法：

public interface Collection<E> extends Iterable<E> {
  ...
  default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }
}

那么所有继承了Collection的接口都可以直接创建Stream，然后再执行Stream里面的操作。所以这么看下来，首先得承认书中的表述是高度抽象且精炼的，这是书籍该做的事情。但从易于理解的角度，我觉得可以说是简洁高效安全的处理集合数据的工具类。如下图所示，Stream是一个中间过程。

需要注意的点

• 首先Stream不是一个数据结构，它不存储任何数据，它是一种数据处理工具，代表了一种能力。
• Stream不会对处理的数据本身做任何修改，永远都是返回新的Stream或者最终的处理结果。
• Stream可以有多个中间操作，但只能有一个终端操作，因为终端操作就求值了。
• 一个Stream只能用一次，不能多次复用。（因为它不存储数据，只是一个转换能力）。

能力范围

Stream随着Java 8的发布已经8年多了，在我有限的职业生涯里，碰到的一些职场新人依然有些人觉得使用for或者iterator来遍历集合更易读易懂。但如果他真正了解Stream所蕴含的能力后，应该会转变想法。下面简单介绍一下Stream都提供了什么样的能力。

1. 生成流

   • java.util.stream.Stream#of(T... values) 。首先stream接口本身提供了一个静态默认方法，可以直接创建，这里的可变参数会被解析成一个数组。

   • java.util.Collection#stream()

   • java.util.Arrays#stream(T[] array)

   • java.nio.file.Files#list(Path dir)

   • java.nio.file.Files#lines(Path path)

   可以看到，可以操作stream的对象基本为List或者Array。

2. 筛选和切片

   这可能是用的最多的功能。对应的方法为：

   • filter：接受一个Predicate断言函数，用来遍历元素是否符合断言条件。可以简单的理解为一个过滤器。
   • distinct：无参数，将所有元素去重，和数据库的distinct关键词能力一样。
   • limit：接受一个int型长度字段，表示要保留多少个元素，需要注意的时候limit并不排序。
   • skip：和limit相对应，接受一个int型长度字段表示跳过多少个元素，也不排序。

   下面举个例子：

   Stream.of("d2", "a2", "b1", "a3", "c1", "a4", "a2", "a1")
           .filter(x -> x.startsWith("a"))
           .distinct()
           .skip(1)
           .limit(3)
           .forEach(System.out::println);
     }
   // output: 
   a3
   a4
   a1
   

3. 映射/转换

   这里主要是map，map代表了一种对应关系，即地图坐标与实际地点的对应关系，我们有了经纬度就可以准确的找到地址，这个例子可以很形象的解释map命名的由来和功能。

   • map：接受一个Function作为参数，即输入一个值，返回另一个值，满足转换的语义。
   • flatmap：同样接受一个Function作为参数，不同的是这个Function中有一个参数是一个stream，返回的也是一个stream，意为将多个stream连成一个stream。

   同样，举个简单的例子：

   Stream.of("d2", "a2", "b1", "a3", "c1", "a4", "a2", "a1")
           .filter(x -> x.startsWith("a"))
           .map(String::toUpperCase)
           .forEach(System.out::println);
   //output
   A2
   A3
   A4
   A2
   A1
   
   List<String> list = Stream.of("Hello", "world!")
           .map(s -> s.split(""))
           .flatMap(Arrays::stream)
           .collect(Collectors.toList());
   System.out.println(list);
   //output
   [H, e, l, l, o, w, o, r, l, d, !]
   

4. 查找和匹配

   这里的能力可以认为是一个加强版的contains方法，具备多种查找匹配能力。

   • allMatch：返回boolean，接受一个Predicate断言，确认全部元素均满足这个条件则返回true，否则返回false
   • anyMatch：与allMatch类似，但从语义上可以区分只要任意元素满足条件即可
   • noneMatch：同样，要求没有任何元素满足条件
   • findFirst：返回一个Optional，里面是满足条件的第一个元素
   • findAny：返回Optional，里面是满足条件的任一元素

   这里需要解惑的是findAny与findFirst的区别，因为这两个都是找到满足条件的元素就返回，但findFirst会在限制并行流的计算，会严格按照集合中元素的顺序来依次查找。findAny就不会有这个限制。如果非并行计算场景，这二者并无区别。

   下面依旧举简单的例子说明：

   boolean b1 = Stream.of("d2", "a2", "b1", "a3", "c1", "a4", "a2", "a1")
           .anyMatch(x -> x.startsWith("a"));
       System.out.println(b1);
   //output: true
   
   String s2 = Stream.of("d2", "a2", "b1", "a3", "c1", "a4", "a2", "a1")
           .filter(x -> x.startsWith("a"))
           .findFirst()
           .get();
       System.out.println(s2);
   //output: a2
   
   String s3 = Stream.of("d2", "a2", "b1", "a3", "c1", "a4", "a2", "a1")
           .filter(x -> x.startsWith("a"))
           .findAny()
           .get();
       System.out.println(s3);
   //output: a2
   
   //换成并行流
   String s4 = Stream.of("d2", "a2", "b1", "a3", "c1", "a4", "a2", "a1")
           .parallel()
           .filter(x -> x.startsWith("a"))
           .findFirst()
           .get();
       System.out.println(s4);
   //output: a2
   
   
   String s5 = Stream.of("d2", "a2", "b1", "a3", "c1", "a4", "a2", "a1")
           .parallel()
           .filter(x -> x.startsWith("a"))
           .findAny()
           .get();
       System.out.println(s5);
   //output: a4
   

5. 归约

   归约是一个比较复杂的数学理论，通常是用于将一个未知的问题转换成另一些已知问题，同时这些已知的问题和未知的问题存在某种关联。这里不做详细探讨。在Stream API有一些方法就是用的类似的归约的思想，将大的集合计算分解成小的函数计算并最终合成结果。

   • reduce
   • collect

   这两个方法都很重要，且都是终端操作，执行完即返回流的计算结果。我们逐个来说，先看reduce。reduce的英文含义为减少、归纳，在stream接口中的定义如下：

   T reduce(T identity, BinaryOperator<T> accumulator);
   
   Optional<T> reduce(BinaryOperator<T> accumulator);
   
   <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner);
   

   这样的方法签名如同天书，先看一个简单的例子：

   Integer i = Stream.of(1, 4, 6, 7, 9).reduce(1, (sum, i) -> sum + i);
   System.out.println(i);
   

   其中reduce我传了2个参数：

   • 1表示初始值，可以不给，不给的话默认从流的第一个元素开始计算，但返回是就是Optional
   • (sum, i) -> sum + i表示计算函数，每次计算的结果都会暂存在sum中，i则是下一个元素

   所以总的来说，这是一个迭代归纳的过程，将多个元素的流按照自己制定的计算规则变成一个元素。不仅仅可以做述职运算，也可以实现复杂对象的转换，先看例子（此例来源于与廖雪峰老师的网站并稍做修改，具体链接：www.liaoxuefeng.com/wiki/125259…

   List<String> props = Lists.newArrayList("profile=native", "debug=true", "logging=warn", "interval=500");
       Map<String, String> map = props.stream()
           .map(kv -> {
             String[] ss = kv.split("=", 2);
             Map<String, String> m = Maps.newHashMap();
             m.put(ss[0], ss[1]);
             return m;
           })
           .reduce(new HashMap<>(), (m, kv) -> {
             m.putAll(kv);
             return m;
           });
       map.forEach((k, v) -> System.out.println(k + " = " + v));
   
   //output:
   logging = warn
   interval = 500
   debug = true
   profile = native
   

   第一个map执行完之后返回了多个小map这里使用reduce进行一个map的累加：

   • new HashMap<>()是初始值，一个空map
   • (m, kv) ->中，m是暂存累加结果，kv表示下一个元素map

   以上看来，reduce的使用场景应该会很广泛，尤其是多个集合合成一个大集合的场景。

   对于多线程的场景，reduce也是支持的，这里先引用一段设计者的话来辅助说明：

   One of the design principles of the Streams API is that the API shouldn't differ between sequential and parallel streams, or put another way, a particular API shouldn't prevent a stream from running correctly either sequentially or in parallel.

   他的意思是说，stream API的设计原则就是让这些方法在顺序执行和并行执行的场景下使用体验一致。其实要让这些方法高度封装，他们在底层实现并行计算，在外面用起来感觉跟单线程一样。reduce就实现了这一点，用到是第三个方法签名：

   <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner);
   

   这里相对之前的签名多了一个combiner，可以直接从字面上理解就是组合多个线程的结果，但为什么是个BinaryOperator呢？先看一个简化版的实现：

   U reduce(I, (U, T) -> U, (U, U) -> U)
   

   • I依然是初始值
   • (U, T) -> U表示归纳的计算方法，值得注意的是这里可以允许传一个比的对象进来，但最终是返回一个U
   • (U, U) -> U这个很关键，这个算式告诉多个线程怎么组合各自的计算结果，所以应该和上面的计算方法保持一致，返回的值也保持一致

   结合一个具体的例子看看：

   List<User> users = Arrays.asList(new User("John", 30), new User("Julie", 35));
   int computedAges =
           users.stream().reduce(0, (partialAgeResult, user) -> partialAgeResult + user.getAge(), Integer::sum);
   

   • (partialAgeResult, user) -> partialAgeResult + user.getAge()表示计算所有人年龄的总和
   • Integer::sum则告诉多个线程，把各个线程的计算结果相加，因为这里是在计算加和。如果计算乘积，这里就应该是(a,b)->a*b

   机智的你一定发现了，这里没有并行啊，只是单线程顺序执行。没错，这就是设计理念的体现，单线程多线程体验一致。这里变成并行计算只需要这样：

   List<User> users = Arrays.asList(new User("John", 30), new User("Julie", 35));
   int computedAges =
           users.stream().parallel().reduce(0, (partialAgeResult, user) -> partialAgeResult + user.getAge(), Integer::sum);
   

   执行结果不变。如果你不嫌麻烦，可以只用这一个reduce方法，但可能会带来一些可读性的障碍。

   因为collect要说的东西也非常多，受限于篇幅影响，我放在下一篇。

小结

本文介绍了stream是什么、创建stream的方法、stream的一些基本API的能力和reduce方法的使用。作为stream最佳实践的开篇，先从stream的基础开始写，后续会逐步深入并总结我个人使用下来的最佳实践，希望大家持续关注，共同学习。