使用java 8 Stream

淩亂°似流年 2022-05-25 10:20 164阅读 0赞

# 使用java 8 Stream #

java8中stream是对集合（Collection)对象的功能上的增强。提供对集合高效的聚合和过滤操作。支持串行和并行两种模式进行汇聚操作。stream并非集合元素，并不会保存数据，如同迭代器一样，单向的不可往复的，遍历一次即用尽。而与迭代器不同的是，stream可以进行并行操作。

## stream的构成： ##

使用流的过程基本分为：数据来源（source）->数据转换->执行结果。每次执行转换后原有的stream不变，返回一个新的stream，致使操作形成链，变成一个管道。

## 数据源的来源: ##

*  集合对象Collection和数组
 *  Collection.stream()
 *  Collection.parallelStream()
 *  Arrays.stream(T array)
 *  Stream.of()
 *  …

## 流的三种操作： ##

*  Intermediate:一个流可以进行零个或多个转换操作，目的就是打开流，执行某种过滤或map映射等返回一个新流，交给下一个操作使用。此类操作都是惰性化的，就是说仅仅调用这个方法并没有开始流的遍历。map/filter/distinct/sorted/peek/limit/skip/parallel/sequential/unordered
 *  Terminal：结果操作，一个流只能有一个该操作，当执行该操作，流就相当于被使用光了，不会再产生其他流，并且会生成一个结果。forEach/toArray/reduce/collect/min/max/count/anyMatch/allMatch/noneMatch/findFirst/findAny/limit
 *  short-circuiting：对于一个无限大的stream，在有限的时间内计算出结果或返回一个新的stream。anyMatch/allMatch/noneMatch/findFirst/findAny/limit

## 常见操作： ##

*  map:映射，map生成的是1:1的映射，每次输入的元素都会按照规则转换成另外一种规则的元素。
    
        /**
         * 简单收集，收集某属性集合
         */
        public Set<String> collectDate(List<UserVO> userList){
          return userList.stream().map(UserVO::getUserName).collect(Collectors.toSet());
        }
 *  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对原始的stream进行某测试，通过测试的元素形成一个新的stream
    
        /**
           * 简单过滤查找列表
           * @param userList
           * @param age
           * @return
           */
          public List<UserVO> simpleFilterFindList(List<UserVO> userList,int age){
            return userList.stream().filter((userVO)->userVO.getAge()==age).collect(Collectors.toList());
          }
 *  forEach:接受lambda表达式，然后在流的每个元素执行表达式
 *  findFirst:该操作是Terminal操作又是short-circuiting操作。总是返回集合的第一个元素的Optional
    
        /**
         * 查找第一个
         * @param userList
         * @return
         */
        public UserVO simpleFilter(List<UserVO> userList,String userName){
          return userList.stream().filter((userVO)->userVO.getUserName().equals(userName)).findFirst().orElse(null);
        }
 *  reduce：该操作主要是将stream元素组合起来，提供一个起始值，然后依照规则跟前面的stream的各个元素的组合。
    
        // 字符串连接，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则是对其stream的前n个元素
    
        /**
           * limit 是取前n个元素
           * skip是丢弃前n个元素
           * @param userList
           * @return
           */
          public List<UserVO> limitAndSkip(List<UserVO> userList){
            return userList.stream().limit(10).skip(2).collect(Collectors.toList());
          }
 *  sorted:对stream的排序，好处是可以先对stream进行其他操作如map,filter,limit等操作再进行排序
    
        /**
         * 排序集合
         * @param userList
         * @return
         */
        public List<UserVO> sortList(List<UserVO> userList){
          return userList.stream().sorted((t1,t2) -> t1.getUserName().compareTo(t2.getUserName())).collect(Collectors.toList());
        }
 *  min/max/distinct:常见的取最大值最小值和去重操作
 *  Match：allMatch/anyMatch/noneMatch,这些都是不需要遍历完所有元素就可以返回结果的，例如allMatch有一个不满足就会返回false。
    
        /**
         * 检查是否所有元素都匹配条件
         * @param userList
         * @return
         */
        public boolean matchAllUser(List<UserVO> userList){
          return userList.stream().allMatch((userVO)->userVO.getAge()>=0);
        }
 *  自定义生成流：Stream.generate  
    通过Supplier接口可以自定义流的生成，常用于随机数，常量或者前后保持某种关系的流。必须使用limit控制流的大小。
    
        /**
           * 自定义流
           */
          public void generateStream(){
            Random ran = new Random();
            Supplier<Integer> stream = ran::nextInt;
            Stream.generate(stream).limit(10).forEach((value) -> System.out.println(value));
          }
 *  Stream.iterate:操作与reduce类似，接受一个初始值，和一个操作，依次执行下去。也需要使用limit进行控制流的大小。
 *  groupingBy:分组
    
        /**
         * 将集合分组
         * 根据年龄分组
         * @param userList
         * @return
         */
        public Map<Integer,List<UserVO>> groupUserVO(List<UserVO> userList){
          return userList.stream().collect(Collectors.groupingBy(userVO -> userVO.getAge()));
        }
 *  partitioningBy:分割
    
        /**
         * 分割数据集，用年龄分割
         * @param userList
         * @return
         */
        public Map<Boolean,List<UserVO>> splitUserList(List<UserVO> userList){
          return userList.stream().collect(Collectors.partitioningBy(userVO -> userVO.getAge()>15));
        }

## 总结 ##

*  流不进行存储，不是一种数据结构，也不会修改底层的数据源，只会产生新的流
 *  Intermediate操作永远是惰性的，很多操作是向后延迟，直到知到多少数据才会开始
 *  stream可以并行处理，无需编写多线程代码
 *  stream可以是无限的，但一般需要limit和findFirst等short-curcutiting方法快速得到结果

## 相关： ##

*  官方文档：[Stream][]
 *  示例代码：[github][]

[Stream]: https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html
[github]: https://github.com/Xchunguang/java8/blob/master/src/main/java/com/mysoft/stream/Collector.java