Java 8中的Stream API 详解

Stream API概述

​ Stream是Java8中的一大亮点，它为容器集合的操作提供了一系列函数式编程方式，节省了大量的重复代码，同时也让代码变得更加简洁精炼。相信在运用java8之前的版本中，我们需要对容器进行操作，手写遍历手写赋值的过程使得代码十分臃肿并且可读性极差。同时它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用 fork/join 并行方式来拆分任务和加速处理过程。可以说stream api是函数式+多核的结合物。

聚合操作

​ 在之前的工作中，曾经有个需求需要构造一个双层的map结构。我们拿到的是一个仓库的全列表，需要根据城市首字母去聚合所有的城市，然后根据城市去聚合这个城市的仓库列表。从复杂度上考虑，需要两次聚合操作，要有两次循环。这里贴一段java8之前的代码实现（相当繁琐，可读性极差）：

public List<TruckStoreDTO> getStorageList() {
       StorageQO storageQO=new StorageQO();
       Page<StorageDTO> storageDTOPage=remoteStorageService.query(storageQO,1,200);
       if(storageDTOPage!=null && storageDTOPage.getTotalNumber()!=0) {
           //获取到原始仓库列表数据
           List<StorageDTO> storageDTOList=storageDTOPage.getItems();
           //根据城市首字母建立一个聚合列表，treemap遍历有序,查询匹配logn复杂度
           TreeMap<String,Map<String,List<StorageDetailDTO>>> cityTreeMap=new TreeMap();
           for(StorageDTO storageDTO:storageDTOList){
               String pinyinCity= PingYingUtils.getPinYinFirstHeadChar(storageDTO.getCity());
               //获取到城市名拼音的首字母大写（同拼音城市列表map<cityCode,list<bean>>）
               String firstPinyin=pinyinCity.toUpperCase();

               //根据城市的code聚合仓库列表，treemap匹配logn复杂度
               Map<String,List<StorageDetailDTO>> cityStorageDTOMap;
               List<StorageDetailDTO> storageDetailDTOList;
               //判断是否包含了该拼音的map<cityCode,List<StorageDetailDTO>
               if (cityTreeMap.containsKey(firstPinyin)) {
                   cityStorageDTOMap=cityTreeMap.get(firstPinyin);

                   StorageDetailDTO storageDetailDTO=new StorageDetailDTO();
                   storageDetailDTO.setStorageCode(storageDTO.getStorageCode());
                   storageDetailDTO.setStorageName(storageDTO.getStorageName());
                   storageDetailDTO.setCityName(storageDTO.getCity());
                   storageDetailDTO.setAddress(storageDTO.getPlace());
                   //如果当前城市已经被插入(同城市列表list<bean>)
                   if(cityStorageDTOMap.containsKey(storageDTO.getCityCode())){
                       //在城市中插入多个仓库
                       storageDetailDTOList=cityStorageDTOMap.get(storageDTO.getCityCode());
                       storageDetailDTOList.add(storageDetailDTO);
                   }
                   //当前城市未被插入过
                   else {
                       storageDetailDTOList =new ArrayList<>();
                       storageDetailDTOList.add(storageDetailDTO);
                       cityStorageDTOMap.put(storageDTO.getCityCode(),storageDetailDTOList);
                   }
               }
               //当前首字母未被插入过
               else {
                   cityStorageDTOMap = new TreeMap<>();
                   cityTreeMap.put(firstPinyin,cityStorageDTOMap);

                   storageDetailDTOList =new ArrayList<>();
                   StorageDetailDTO storageDetailDTO=new StorageDetailDTO();
                   storageDetailDTO.setStorageCode(storageDTO.getStorageCode());
                   storageDetailDTO.setStorageName(storageDTO.getStorageName());
                   storageDetailDTO.setCityName(storageDTO.getCity());
                   storageDetailDTO.setAddress(storageDTO.getPlace());
                   storageDetailDTOList.add(storageDetailDTO);
                   cityStorageDTOMap.put(storageDTO.getCityCode(),storageDetailDTOList);
                   cityTreeMap.put(firstPinyin,cityStorageDTOMap);
               }
           }
           List<TruckStoreDTO> truckStoreDTOList=new ArrayList<>();
           for(Map.Entry cityEntry:cityTreeMap.entrySet()){
               TruckStoreDTO truckStoreDTO=new TruckStoreDTO();
               Map<String,List<StorageDetailDTO>> storageDetailListMap=(Map<String,List<StorageDetailDTO>>)cityEntry.getValue();
               List<CityStorageDTO> cityStorageDTOList=new ArrayList<>();
               for(Map.Entry storageEntry:storageDetailListMap.entrySet() ){
                   List<StorageDetailDTO> storageDetailDTOList=(List<StorageDetailDTO>)storageEntry.getValue();
                   CityStorageDTO cityStorageDTO=new CityStorageDTO();
                   cityStorageDTO.setCityName(storageDetailDTOList.get(0).getCityName());
                   cityStorageDTO.setCityCode((String)storageEntry.getKey());
                   cityStorageDTO.setStorageDetailDTOList(storageDetailDTOList);
                   cityStorageDTOList.add(cityStorageDTO);
               }
               truckStoreDTO.setCityStorageDTOList(cityStorageDTOList);
               truckStoreDTO.setCityListKey((String)cityEntry.getKey());
               truckStoreDTOList.add(truckStoreDTO);
           }
           return truckStoreDTOList;
       }
       return null;
   }

这种实现的弊端：

1.太多的循环导致可读性极差

2.重复冗余的代码过多

那么我们希望通过Stream API去改善和优化这段代码，因为这段是之前在项目中的一段代码，我在这里进行模拟操作：

package StreamAPI;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Created by yqz on 8/14/18.
 */
public class StorageTest {
    public static void main(String[] args) {
        ArrayList<StorageDTO> arrayList=new ArrayList();
        for(int i=0;i<27;i++){
            StorageDTO storageDTO=new StorageDTO();
            char firstKey=(char) (i+65);
            storageDTO.setCityFirstKey(String.valueOf(firstKey));
            for(int j=0;j<3;j++) {
                String cityName="city:"+(char) (j+65);
                storageDTO.setCityName(cityName);
                storageDTO.setStorageName("storage:"+j);
                arrayList.add(storageDTO);
            }
        }//构造一个两次聚合的仓库数组列表
        Stream stream= arrayList.stream();
        Map<String,Map<String,List<StorageDTO>>>storageListMap=(Map<String,Map<String,List<StorageDTO>>>)stream.collect(Collectors.groupingBy(StorageDTO::getCityFirstKey,Collectors.groupingBy(StorageDTO::getCityName)));
        //通过stream的聚合操作可以直接完成上面的一堆代码的操作，一句代码vs一堆代码
    }
}

我们可以看到这两种方式的对比是非常明显的，使用Stream API的聚合操作，代码可读性更强。

流的使用详解

​ 一个流在处理的过程中可能有Intermediate（对原数据创建流这个过程会对数据进行过滤和筛选，这类操作都是惰性化的（lazy），就是说，仅仅调用到这类方法，并没有真正开始流的遍历）。Terminal操作会开始真实的遍历过程，会将先前的lazy的遍历条件全部执行。

​ lazy操作的意思是我们在进行类似filter操作以及limit等操作，实际上并没有开始执行，因为这样如果执行会面临比较大的效率问题。一次循环执行所有的lazy条件，这是对函数式编程的一种技能上的提升。

流是如何构造

​ 当我们需要去获取或者构造一个流的时候，因为流提供的是一种聚合操作，所以流的数据源是不分层的，类似于简单的对象列表，是没有维度的。那么我们可以通过数组去构造或者通过数组去获得流。常见的几种流的构造方法：

Stream stream = Stream.of("a", "b", "c");//单纯通过数组去构造流

String [] strArray = new String[] {"a", "b", "c"};
stream = Stream.of(strArray);
stream = Arrays.stream(strArray);
//通过数组容器直接获取到流应该是最常用的一种方式
List<String> list = Arrays.asList(strArray);
stream = list.stream();

流的主要API

​ 这个模块会主要展示流的几种主要的api，这里根据Intermediate，Short-circuiting，Terminal进行分类：

• Intermediate：

  map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered

• Terminal：

  forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator

• Short-circuiting：

  anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit

  我们下面看一下 Stream 的比较典型用法：

map/flatMap

map提供流数据一对一的映射操作：

ArrayList<String> arrayList=new ArrayList<>();
       arrayList.add("I");
       arrayList.add("LOVE");
       arrayList.add("U");
       arrayList.add("TOO");
       arrayList.add("MUCH");
       Stream<String> stream=arrayList.stream();
       //用map将字段映射成小写
       List<String> stringList=stream.map(String::toLowerCase).collect(Collectors.toList());
       System.out.println(stringList);

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());
//将一个数组列表的数据扁平化，一对多映射操作

filter

filter操作进行进行过滤流数据。例如我们可以对数据急性偶数和奇数的过滤，类似的操作：

Integer[] sixNums = {1, 2, 3, 4, 5, 6};
Integer[] evens =
Stream.of(sixNums).filter(n -> n%2 == 0).toArray(Integer[]::new);
//过滤数据

List<String> output = reader.lines().
 flatMap(line -> Stream.of(line.split(REGEXP))).
 filter(word -> word.length() > 0).
 collect(Collectors.toList());
//过滤单词，flatMap将一行单词转换为一个单词列表

foreach

forEach 是为 Lambda 而设计的，保持了最紧凑的风格。而且 Lambda 表达式本身是可以重用的，非常方便。当需要为多核系统优化时，可以 parallelStream().forEach()，只是此时原有元素的次序没法保证，并行的情况下将改变串行时操作的行为，此时 forEach 本身的实现不需要调整，而 Java8 以前的 for 循环 code 可能需要加入额外的多线程逻辑。

roster.stream()
 .filter(p -> p.getGender() == Person.Sex.MALE)
 .forEach(p -> System.out.println(p.getName()));

另外需要注意的是如果对一个stream进行两次terminal操作，例如：

stream.forEach(element -> doOneThing(element));
stream.forEach(element -> doAnotherThing(element));

运行时会报错：

Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed 
	at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:229)
	at java.util.stream.ReferencePipeline.collect(ReferencePipeline.java:499)
	at StreamAPI.StreamAPITest.main(StreamAPITest.java:33)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:497)
	at com.intellij.rt.execution.application.AppMain.main(AppMain.java:144)

那么如果我们需要在流数据过滤的过程中进行打印，可以不用terminal操作，采用Intermediate操作，上面的代码可以通过peek操作达到打印的效果：

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))//不是teminal操作，Intermediate操作不会报错
 .collect(Collectors.toList());

reduce

字符串拼接、数值的 sum、min、max、average 都是特殊的 reduce，例如 Stream 的 sum 就相当于

Integer sum = integers.reduce(0, (a, b) -> a+b); //前面是是初始值，右边是操作的元素的函数
Integer sum = integers.reduce(0, Integer::sum);://sum的简写方式

//找出最长的单词用reduce
Optional<String> longest=stream.reduce((s1, s2)->s1.length()>s2.length()?s1:s2);
System.out.println("reduce操作找出最长的单词字符串:");
System.out.println(longest.get());
//reduce操作拼接字符串
String concatStr=stream.reduce("",String::concat);
System.out.println("reduce操作拼接字符串"+concatStr);

limit/skip/sorted

limit 返回 Stream 的前面 n 个元素；skip 则是扔掉前 n 个元素（它是由一个叫 subStream 的方法改名而来），正常的sorted操作：

List<Person> personList=persons.stream().sorted((p1,p2)->p1.getAge().compareTo(p2.getAge())).limit(3).collect(Collectors.toList());

讲到这里可能大家比较好奇的是，这个自带的api是如何保证执行效率的，或者说它内部的时间效率如果是n2那作为调用方其实是未知的。那么实际上排序的时间复杂度是 O(n log n)

Match

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

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

List<Person> persons = new ArrayList();
persons.add(new Person(1, "name" + 1, 10));
persons.add(new Person(2, "name" + 2, 21));
persons.add(new Person(3, "name" + 3, 34));
persons.add(new Person(4, "name" + 4, 6));
persons.add(new Person(5, "name" + 5, 55));
boolean isAllAdult = persons.stream().
 allMatch(p -> p.getAge() > 18);
System.out.println("All are adult? " + isAllAdult);
boolean isThereAnyChild = persons.stream().
 anyMatch(p -> p.getAge() < 12);
System.out.println("Any child? " + isThereAnyChild);

输出：

All are adult? false
Any child? true

总结

运用Stream API最明显的感觉是提供了类似c++提供的一系列STL容器操作。帮主我们对容器进行更方便可读性更强的处理，减少了很多常用的重复代码。之后在工作种可以用这种写法，这里做一个总结stream的特性：

• 不是数据结构

• 它没有内部存储，它只是用操作管道从 source（数据结构、数组、generator function、IO channel）抓取数据。
• 它也绝不修改自己所封装的底层数据结构的数据。例如 Stream 的 filter 操作会产生一个不包含被过滤元素的新 Stream，而不是从 source 删除那些元素。

• 所有 Stream 的操作必须以 lambda 表达式为参数
• 不支持索引访问

• 你可以请求第一个元素，但无法请求第二个，第三个，或最后一个。不过请参阅下一项。

• 很容易生成数组或者 List
• 惰性化

• 很多 Stream 操作是向后延迟的，一直到它弄清楚了最后需要多少数据才会开始。
• Intermediate 操作永远是惰性化的。

• 并行能力

• 当一个 Stream 是并行化的，就不需要再写多线程代码，所有对它的操作会自动并行进行的。

• 集合有固定大小，Stream 则不必。limit(n) 和 findFirst() 这类的 short-circuiting 操作可以对无限的 Stream 进行运算并很快完成。