JDK1.8新特性---＞stream流

1. 静态方法流、集合流、数据流

// 静态方法流
Stream.of(1, 2, 3, 4);
// 集合流
new ArrayList<>().stream();
// 数组流
Arrays.stream(new int[5]);

1. Person类

   package com.xiaoge.stream;
   
   import lombok.*;
   
   
   @ToString
   @AllArgsConstructor
   @NoArgsConstructor
   @Data
   @Builder
   public class Person {
   
       private String name;
   
       private Integer age;
   
       private String sex;
   
   }
   

2. StreamTest类

   public class StreamTest {
   
       public static void main(String[] args) {
           List list = new ArrayList<>();
   
           Person person1 = new Person("张三", 18, "男");
           Person person2 = new Person("李四", 20, "男");
           Person person3 = new Person("王五", 25, "女");
           Person person4 = new Person("赵七", 30, "男");
   
           list.add(person1);
           list.add(person2);
           list.add(person3);
           list.add(person4);
       }
   }
   

   map(): 对集合元素逐个进行函数操作，映射成全新的一个集合

   // 收集所有对象的age, 收集成一个list
   List ages = list
       .stream()
       .map(Person::getAge)
       .collect(Collectors.toList());
   System.out.println(ages);
   
   // 结果
   [18, 20, 25, 30]
   

   flatMap():接收一个函数作为参数，将流中的值进行函数操作后，然后把所有流连接成一个流

   List list = Arrays.asList("hello", "xiaoge");
   System.out.println(list);       
   
   List collect1 = list
       .stream()
       .map(x -> x.split(""))
       .flatMap(Arrays::stream)
       .collect(Collectors.toList());
   
   System.out.println(collect1);
   
    // 结果
    [hello, xiaoge]
    [h, e, l, l, o, x, i, a, o, g, e]
   

   filter(): 按条件过滤

   List sexList = list
        .stream()
        .filter(person -> "女".equals(person.getSex()))
        .collect(Collectors.toList());
   System.out.println(sexList);
   
   // 结果
   [Person(name=王五, age=25, sex=女)]
   

   limit(): 按个数取出

   // 只取前面两个对象
   list.stream().limit(2).forEach(System.out::println);
   
   // 结果
   Person(name=张三, age=18, sex=男)
   Person(name=李四, age=20, sex=男)
   

   skip(): 跳过前(指定值)个截取

   // 跳过前2个截取
   list.stream().skip(2).forEach(System.out::println);
   
   // 结果
   Person(name=王五, age=25, sex=女)
   Person(name=赵七, age=30, sex=男)
   

   distinct(): 去重

   List list = new ArrayList<>();
   
   Person person1 = new Person("张三", 18, "男");
   Person person2 = new Person("李四", 20, "男");
   Person person3 = new Person("王五", 25, "女");
   Person person4 = new Person("赵七", 30, "男");
   Person person5 = new Person("赵七", 30, "男");
   
   list.add(person1);
   list.add(person2);
   list.add(person3);
   list.add(person4);
   list.add(person5);
   
   // 去重
   list.stream().distinct().forEach(System.out::println);
   
   
   // 结果
   Person(name=张三, age=18, sex=男)
   Person(name=李四, age=20, sex=男)
   Person(name=王五, age=25, sex=女)
   Person(name=赵七, age=30, sex=男)
   

   sorted(): 排序，可自定义排序

   List list2 = list.stream()
       .sorted((x, y) -> {
           return x.getAge().compareTo(y.getAge());
       }).collect(Collectors.toList());
   
   System.out.println(list2);
   

   Collectors.toMap: 自定义组装Map

   Map map = list
   	.stream()
   	.collect(Collectors.toMap(Person::getName, Person::getAge));
   
   map.forEach((key, value) -> {
       System.out.println("key: " + key + " value: " + value);
   });
   
   // 结果
   key: 李四 value: 20
   key: 张三 value: 18
   key: 王五 value: 25
   key: 赵七 value: 30
   

   Collectors.groupingBy:按条件进行分组

   Map> map = list
       .stream()
       .collect(Collectors.groupingBy(Person::getSex));
   map.forEach((key, value) -> {
       System.out.println("key: " + key + " value: " + value);
   });
   
   
   // 结果
   key: 女 value: [Person(name=王五, age=25, sex=女)]
   key: 男 value: [Person(name=张三, age=18, sex=男), Person(name=李四, age=20, sex=男), Person(name=赵七, age=30, sex=男)]
   

   查询匹配

   // 有一个或一个以上的元素满足函数参数计算结果为true
   boolean match = list.stream().anyMatch(x -> x.getAge() == 18);
   // 全部满足函数计算及结果为true
   boolean allMatch = list.stream().allMatch(x -> x.getAge() == 18);
   // 不包含有满足这个判断的元素或者流中元素为空的时候方法返回true
   boolean noneMatch = list.stream().noneMatch(x -> x.getAge() == 18);
   // 查找第一个
   Person person = list.stream().findFirst().get();
   // 正常情况下一般会取第一个元素，在并行流的情况下会随机取一个元素  list.parallelStream()并行流
   Person person5 = list.stream().findAny().get();
   // 数量
   long count = list.stream().count();
   // 年龄最大
   Person person6 = list.stream().max((x, y) -> x.getAge().compareTo(y.getAge())).get();
   // 年龄最小
   Person person7 = list.stream().min(Comparator.comparing(Person::getAge)).get();
   
   System.out.println(match);
   System.out.println(allMatch);
   System.out.println(noneMatch);
   System.out.println(person);
   System.out.println(person5);
   System.out.println(count);
   System.out.println(person6);
   System.out.println(person7);
   
   
   // 结果
   true
   false
   false
   Person(name=张三, age=18, sex=男)
   Person(name=张三, age=18, sex=男)
   4
   Person(name=赵七, age=30, sex=男)
   Person(name=张三, age=18, sex=男)
   

   reduce():将流中的数据反复结合起来得到一个值

   //ma->reduce
   Integer sum = list
       .stream()
       .map(Person::getAge)
       .reduce(Integer::sum).get();
   System.out.println(sum);
   
   //设置初始值
   List list = Arrays.asList(1, 2, 3);
   System.out.println(list.stream().reduce(100, (x, y) -> x * y));
   
   //不设置初始值
   List list = Arrays.asList(2, 2, 3);
   System.out.println(list.stream().reduce( (x, y) -> x * y));
   
   // 结果
   93
   600
   Optional[12]