jdk8-stream-api

1.stream简介

stream 是一个用来处理集合个数组的api

jdk 8 引入strream的原因：1.去掉for循环，使编程变的更加简单（实际运行效率可能没有for循环高）2.parallel,多核友好，java函数式编程使得编写并行程序如此简单，你需要的仅仅是调用一下parallel()方法

stream的特性： 1.不是数据结构，没有内存存储   2.不支持索引（没有数据，类似于spark中的RDD,只是搭建计算框架，在最后执行时才执行整个流程）　  3.延迟计算   4.支持并行  5.很容易生成数组和集合   6.支持过滤查找转化等多种操作

2.Stream运行机制

Stream分为 源source，中间操作，终止操作 流的源可以是一个数组、一个集合、一个生成器方法，一个I/O通 道等等。 一个流可以有零个和或者多个中间操作，每一个中间操作都会返回 一个新的流，供下一个操作使用。一个流只会有一个终止操作 Stream只有遇到终止操作，它的源才开始执行遍历操作

3.Stream的创建

1、通过数组   2、通过集合来   3、通过Stream.generate方法来创建      4、通过Stream.iterate方法来创建    5、其他API创建

创建stream对象，of 方法中，参数为：（T... ..values） 可看做是一个多个同种类型对象组成的集合，forEach()方法，参数为：（Consumer<? super T>action）,即一个Consumer接口，泛型为调用Stream中所装载的对象的父类或者自己，比如下面，调用对象为Stream<Student>,泛型为它的父类Teacher

 public static void common_fileInputStream() throws IOException {
        String[] arr = {"a", "b", "c", "d", "e", "f", "g", "h"};
        Student stu = new Student("q");
        Stream<String>stud=Stream.of(arr);
        Stream<Student>student=Stream.of(stu,stu,stu,stu);/**1 of  : (T... values)*/
        Consumer<Teacher> consumer=new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println("o = " + o);
            }
        };
        student.forEach(consumer);/**参数：(Consumer<? super T> action)*/
       // stud.forEach(consumer);
    }

4.Stream常用API

中间操作： 过滤 filter 去重 distinct 排序 sorted 截取 limit、skip 转换 map/flatMap  其他 peek

终止操作： 循环 forEach 计算 min、max、count、 average 匹配 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny 汇聚 reduce 收集器 toArray collec

5.代码体现

1.创建Stream并遍历

 List<String> list = Arrays.asList("string", "double", "int");
        Stream<List> stream = Stream.of(list);
        /**写法一*/
        /*Consumer<List>consumer=new Consumer<List>() {
            @Override
            public void accept(List list) {
                System.out.println("list = " + list);
            }
        };
        stream.forEach(consumer);*/
        // Consumer<List> consumer = (arr) -> System.out.println(arr);
        /**写法二*/
        stream.forEach((arr) -> System.out.println(arr));

        /**写法三*/
        Consumer<List> consumer = System.out::println;
        /**函数式接口对应实例对象的方法的引用*/
        //stream.forEach(System.out::println);

上述代码中，写法一为常规操作，写法二使用了通常的lanbad表达式，写法三中使用了实例对象引用方法的模式，无论哪种，都没有手动调用Consumer的默认方法accept方法，个人理解forEach中应该有对该方法的默认调用，并且在调用时传入了参数。

2.创建stream的方式

@Test
    public void createStream(){
        /**方法一,通过集合和数组创建*/
      List<String>lis=new ArrayList<String>();
      lis.add("a");lis.add("b");lis.add("c");
      /**数组*/
      List<String>lis1=Arrays.asList("a","b","c");
      Stream<List>stream1=Stream.of(lis);

      /**方法二，通过generate方式创建*/
        Stream<Integer>sin=Stream.generate(()->1);
        /**这种创建的方式创建出来的流时无限的，需要limit做限制*/
        sin.limit(3).forEach(System.out::println);
        /**输出结果：1,1,1*/

      /**方法三，使用迭代器方式创建*/
        Stream<Integer>str=Stream.iterate(0,x->x+1);
        str.limit(2).forEach(System.out::println);
       /**創建方法4*/
       String string="abc";
       IntStream intStream=string.chars();
       intStream.forEach(System.out::println);
       /**輸出結果：97，98，99,即hashcode碼值*/

    }

3.stream的几种常见用法组合

1排序，使用排序的时候需要注意排序的值为null的情况

 @Test
    public void streamCommonTest() {
        /**排序功能*/
        String arr[] = {"baierhu", "zhaowenb", "cheng", "2"};
        Stream<String> str = Stream.of(arr);
        //List list= str.sorted().collect(Collectors.toList());
        //System.out.println("arrr = " + list);
        /**输出结果：默认为字典排序：arrr = [2, baierhu, cheng, zhaowenb]*/

        List list1=str.sorted(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }
        }).collect(Collectors.toList());
        System.out.println(list1);
        /**输出结果：按照长度排序*/

       Student [] stu={new Student(1,"baierhu"),new Student(2,"zwen"),new Student(null,"aaa"),new Student(null,"chaochao")} ;
       /**Stream.of(stu).sorted(new Comparator<Student>() {
           @Override
           public int compare(Student o1, Student o2) {
               return o1.getName().length()-o2.getName().length();
           }
       }).collect(Collectors.toList()).forEach(System.out::println);*/
        // 输出结果：Student{id=2, name='zwen'}
        //Student{id=1, name='baierhu'}
        //Student{id=null, name='chaochao'}

        List<Student>lis=Stream.of(stu).sorted((a,b)->a.getName().length()-b.getName().length()).collect(Collectors.toList());
        System.out.println("lis = " + lis);

        List<Student>lis111=Stream.of(stu).sorted((a,b)->{
            if(a.getId()==null && b.getId()==null) return 0;
            else if(a.getId()==null) return 0-b.getId();
            else if(b.getId()==null) return a.getId()-0;
            else return a.getId()-b.getId();}).collect(Collectors.toList());
        System.out.println("lis111 = " + lis111);
        /**输出：lis111 = [Student{id=null, name='aaa'}, Student{id=null, name='chaochao'}, Student{id=1, name='baierhu'}, Student{id=2, name='zwen'}]*/
    }

2、build

    @Test
    public void buildTest(){
        /**build,个人理解可以用add方法多添加几个东西至Stream*/
        String arr[] = {"baierhu", "zhaowenb", "cheng", "2"};
        Stream.Builder builder = Stream.builder().add(arr);
        builder.build().forEach((a)->{
            String aa[]=(String[])a;
            System.out.println(Arrays.toString(aa));
        });
    }
/**输出：[baierhu, zhaowenb, cheng, 2]*/

3.filter  注意：方法二中可以在传入参数的时候带上参数类型，否则会默认将参数类型定为object类型

 @Test
    public void buildFilter(){
        /**build,个人理解可以用add方法多添加几个东西至Stream*/
        String arr[] = {"baierhu", "zhaowenb", "cheng", "2"};
        Stream<String> builder = Stream.of(arr);
        Predicate<String>pr=new Predicate<String>() {
            @Override
            public boolean test(String s) {
                if(s.length()>4) return true;
                return false;
            }
        };
        /**方法一*/
        List<String> aa=builder.filter(pr).collect(Collectors.toList());
        System.out.println("ob = " + aa);
        /**方法二，简单写法*/
        List<String> bb=builder.filter((String a)->a.length()>5).collect(Collectors.toList());
        System.out.println(bb);
    }
/**输出：[baierhu, zhaowenb]*/

4.collect(mapping,joining,groupby)  收集

//创建数据
List<User> listUser = new ArrayList<>();
listUser.add(new User("李白", 20, true));
listUser.add(new User("杜甫", 40, true));
listUser.add(new User("李清照", 18, false));
listUser.add(new User("李商隐", 23, true));
listUser.add(new User("杜牧", 39, true));
listUser.add(new User("苏小妹", 16, false));

这个User就是一个普通的Bean对象，有name（姓名）、age（年龄）、gender（性别）三个属性及对应的set/get方法。

joining方法：

从 joining 方法的定义可以看到，这里重载了3个 joining 方法：无参数，1个参数，3个参数。然后从参数命名上看delimiter-分隔符、prefix-前缀、suffix-后缀大约可以猜出参数的作用了，然后再看注释的参数说明

Returns a {@code Collector} that concatenates the input elements,separated by the specified delimiter, with the specified prefix and suffix, in encounter order.

将指定的值join成字符串

String join1 = listUser.stream().map(User::getName).collect(Collectors.joining());
System.out.println("join后的结果：" + join1); // 输出==》 李白杜甫李清照李商隐杜牧苏小妹

将List中的用户名join成中间用","分隔的字符串

String join2 = listUser.stream().map(User::getName).collect(Collectors.joining(","));
System.out.println("join后的结果：" + join2); // 输出==》李白,杜甫,李清照,李商隐,杜牧,苏小妹

将List中的用户名join成以前缀是"{"，后缀是"}"，中间用","分隔的字符串

String join3 = listUser.stream().map(User::getName).collect(Collectors.joining(",", "{", "}"));
System.out.println("join后的结果：" + join3); // 输出==》{李白,杜甫,李清照,李商隐,杜牧,苏小妹}

mapping方法的定义如图

方法有2个参数，Function类型的mapper和Collector类型的downstream。通过注释可以看到方法是通过参数mapper函数来处理List中的每一个数据，然后用downstream来将处理后的数据收集起来。举例说明：

取出List中所有人的姓名放到一个新的List中去

// 定义一个入参为User，返回String的函数
Function<User,String> mapper=(user)->{
    return user.getName();
};
List<String> userNames = listUser.stream().collect(Collectors.mapping(mapper, Collectors.toList()));

以上代码再简写一下：

List<String> userNames = listUser.stream().collect(Collectors.mapping((user)->{return user.getName();}, Collectors.toList()));

或者：

List<String> userNames = listUser.stream().collect(Collectors.mapping(User::getName, Collectors.toList()));

以上mapping 和joining转载于：https://blog.csdn.net/u012843361/article/details/83090199

group by

转载于：https://blog.csdn.net/u014231523/article/details/102535902

public Product(Long id, Integer num, BigDecimal price, String name, String category) {
    this.id = id;
    this.num = num;
    this.price = price;
    this.name = name;
    this.category = category;
}

Product prod1 = new Product(1L, 1, new BigDecimal("15.5"), "面包", "零食");
Product prod2 = new Product(2L, 2, new BigDecimal("20"), "饼干", "零食");
Product prod3 = new Product(3L, 3, new BigDecimal("30"), "月饼", "零食");
Product prod4 = new Product(4L, 3, new BigDecimal("10"), "青岛啤酒", "啤酒");
Product prod5 = new Product(5L, 10, new BigDecimal("15"), "百威啤酒", "啤酒");
List<Product> prodList = Lists.newArrayList(prod1, prod2, prod3, prod4, prod5);

• 按照类目分组：

  Map<String, List<Product>> prodMap= prodList.stream().collect(Collectors.groupingBy(Product::getCategory));
  
  //{"啤酒":[{"category":"啤酒","id":4,"name":"青岛啤酒","num":3,"price":10},{"category":"啤酒","id":5,"name":"百威啤酒","num":10,"price":15}],"零食":[{"category":"零食","id":1,"name":"面包","num":1,"price":15.5},{"category":"零食","id":2,"name":"饼干","num":2,"price":20},{"category":"零食","id":3,"name":"月饼","num":3,"price":30}]}

• 按照几个属性拼接分组：

  Map<String, List<Product>> prodMap = prodList.stream().collect(Collectors.groupingBy(item -> item.getCategory() + "_" + item.getName()));
  
  //{"零食_月饼":[{"category":"零食","id":3,"name":"月饼","num":3,"price":30}],"零食_面包":[{"category":"零食","id":1,"name":"面包","num":1,"price":15.5}],"啤酒_百威啤酒":[{"category":"啤酒","id":5,"name":"百威啤酒","num":10,"price":15}],"啤酒_青岛啤酒":[{"category":"啤酒","id":4,"name":"青岛啤酒","num":3,"price":10}],"零食_饼干":[{"category":"零食","id":2,"name":"饼干","num":2,"price":20}]}

• 根据不同条件分组

  Map<String, List<Product>> prodMap= prodList.stream().collect(Collectors.groupingBy(item -> {
      if(item.getNum() < 3) {
          return "3";
      }else {
          return "other";
      }
  }));
  
  //{"other":[{"category":"零食","id":3,"name":"月饼","num":3,"price":30},{"category":"啤酒","id":4,"name":"青岛啤酒","num":3,"price":10},{"category":"啤酒","id":5,"name":"百威啤酒","num":10,"price":15}],"3":[{"category":"零食","id":1,"name":"面包","num":1,"price":15.5},{"category":"零食","id":2,"name":"饼干","num":2,"price":20}]}

  多级分组
  要实现多级分组，我们可以使用一个由双参数版本的Collectors.groupingBy工厂方法创 建的收集器，它除了普通的分类函数之外，还可以接受collector类型的第二个参数。那么要进 行二级分组的话，我们可以把一个内层groupingBy传递给外层groupingBy，并定义一个为流 中项目分类的二级标准。

  Map<String, Map<String, List<Product>>> prodMap= prodList.stream().collect(Collectors.groupingBy(Product::getCategory, Collectors.groupingBy(item -> {
      if(item.getNum() < 3) {
          return "3";
      }else {
          return "other";
      }
  })));
  
  //{"啤酒":{"other":[{"category":"啤酒","id":4,"name":"青岛啤酒","num":3,"price":10},{"category":"啤酒","id":5,"name":"百威啤酒","num":10,"price":15}]},"零食":{"other":[{"category":"零食","id":3,"name":"月饼","num":3,"price":30}],"3":[{"category":"零食","id":1,"name":"面包","num":1,"price":15.5},{"category":"零食","id":2,"name":"饼干","num":2,"price":20}]}}

  按子组收集数据

• 求总数

  Map<String, Long> prodMap = prodList.stream().collect(Collectors.groupingBy(Product::getCategory, Collectors.counting()));
  
  //{"啤酒":2,"零食":3}

• 求和

  Map<String, Integer> prodMap = prodList.stream().collect(Collectors.groupingBy(Product::getCategory, Collectors.summingInt(Product::getNum)));
  
  //{"啤酒":13,"零食":6}

• 把收集器的结果转换为另一种类型

  Map<String, Product> prodMap = prodList.stream().collect(Collectors.groupingBy(Product::getCategory, Collectors.collectingAndThen(Collectors.maxBy(Comparator.comparingInt(Product::getNum)), Optional::get)));
  
  //{"啤酒":{"category":"啤酒","id":5,"name":"百威啤酒","num":10,"price":15},"零食":{"category":"零食","id":3,"name":"月饼","num":3,"price":30}}

• 联合其他收集器

  Map<String, Set<String>> prodMap = prodList.stream().collect(Collectors.groupingBy(Product::getCategory, Collectors.mapping(Product::getName, Collectors.toSet())));
  
  //{"啤酒":["青岛啤酒","百威啤酒"],"零食":["面包","饼干","月饼"]}

map

转载于：https://zhangzw.com/posts/20191205.html

// 简单对象
@Accessors(chain = true) // 链式方法
@lombok.Data
class User {
    private String id;
    private String name;
}

然后有这样一个 List：

List<User> userList = Lists.newArrayList(
        new User().setId("A").setName("张三"),
        new User().setId("B").setName("李四"),
        new User().setId("C").setName("王五")
);

我们希望转成 Map 的格式为：

A-> 张三 
B-> 李四 
C-> 王五

过去的做法（循环）：

Map<String, String> map = new HashMap<>();
for (User user : userList) {
    map.put(user.getId(), user.getName());
}

jdk 1.8

userList.stream().collect(Collectors.toMap(User::getId, User::getName));

当然，如果希望得到 Map 的 value 为对象本身时，可以这样写：

userList.stream().collect(Collectors.toMap(User::getId, t -> t));
 或：
userList.stream().collect(Collectors.toMap(User::getId, Function.identity()));

关于 Collectors.toMap 方法

Collectors.toMap 有三个重载方法：

toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper);
toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper,
        BinaryOperator<U> mergeFunction);
toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper,
        BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier);

参数含义分别是：

keyMapper：Key 的映射函数

valueMapper：Value 的映射函数

mergeFunction：当 Key 冲突时，调用的合并方法

mapSupplier：Map 构造器，在需要返回特定的 Map 时使用

还是用上面的例子，如果 List 中 userId 有相同的，使用上面的写法会抛异常：

List<User> userList = Lists.newArrayList(
        new User().setId("A").setName("张三"),
        new User().setId("A").setName("李四"), // Key 相同
        new User().setId("C").setName("王五")
);
userList.stream().collect(Collectors.toMap(User::getId, User::getName));

// 异常：
java.lang.IllegalStateException: Duplicate key 张三
    at java.util.stream.Collectors.lambda$throwingMerger$114(Collectors.java:133)
    at java.util.HashMap.merge(HashMap.java:1245)
    at java.util.stream.Collectors.lambda$toMap$172(Collectors.java:1320)
    at java.util.stream.ReduceOps$3ReducingSink.accept(ReduceOps.java:169)
    at java.util.ArrayList$ArrayListSpliterator.forEachRemaining(ArrayList.java:1374)
    at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:481)
    at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:471)
    at java.util.stream.ReduceOps$ReduceOp.evaluateSequential(ReduceOps.java:708)
    at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
    at java.util.stream.ReferencePipeline.collect(ReferencePipeline.java:499)
    at Test.toMap(Test.java:17)
    ...

这时就需要调用第二个重载方法，传入合并函数，如：

userList.stream().collect(Collectors.toMap(User::getId, User::getName, (n1, n2) -> n1 + n2));

// 输出结果：
A-> 张三李四
C-> 王五 

第四个参数（mapSupplier）用于自定义返回 Map 类型，比如我们希望返回的 Map 是根据 Key 排序的，可以使用如下写法：

List<User> userList = Lists.newArrayList(
        new User().setId("B").setName("张三"),
        new User().setId("A").setName("李四"),
        new User().setId("C").setName("王五")
);
userList.stream().collect(
    Collectors.toMap(User::getId, User::getName, (n1, n2) -> n1, TreeMap::new)
);

// 输出结果：
A-> 李四
B-> 张三
C-> 王五 

flatmap

List<Long> listFlatLong = listFlat.stream()
                .flatMap(employees -> employees.stream())
                .flatMapToLong(employee -> LongStream.of(employee.getId()))
                .boxed()
                .collect(Collectors.toList());
        System.out.println("listFlatLong = " + listFlatLong);

当有双层时，比如List<List<>>或者List<Map<>>比较适合使用这种方式

如果使用的是map方法，返回的是[ ...['y', 'o', 'u', 'r'], ['n', 'a', 'm', 'e']]

如果使用的是flatMap方法，返回的是['y', 'o', 'u', 'r', 'n', 'a', 'm', 'e']

这是map和flatMap的区别