Java中的Stream API :)

一、流的形成方法

1. 集合 ---> 流
   集合.stream()
2. 数字流的形成(int型为例）
   IntStram.of(1,2,3,4)
3. 数组 ---> 流
   Arrays.stream(数组）
4. 把文件中的每一行读出来作为流的元素
   Files.lines(Paths.get("aaa.txt"))
5. 生产者接口的使用 
   Stream.generate(生产者接口)
   举例：
   生成5个随机数
   Random r = new Random();
   Stream.generate( () -> r.nextInt(100) ).limit(5).forEach( x->System.out.println(x));    

二、重要接口

1. Predicate 断言接口
    对应的lambda:
    一个参数，返回结果是boolean
    (a) -> {  return true|false; }
    
2. Function 函数接口
    对应的lambda:
    一个参数，一个返回结果，参数和返回结果的类型可以不一样
    
3. BiPredicate 双参数断言
    对应的lambda:
    两个参数，返回结果是boolean
    (a, b) -> {  return true|false; }
    
4. BiFunction 双参数函数接口
    两个参数，一个结果
    (a, b) -> { 根据ab返回一个结果}
5. Consumer 消费接口
    一个参数 没有结果
    (a) -> { 不需要return }
    
6. BiConsumer 双参数消费接口
    两个参数，没有结果
    
7. Supplier 生产者接口
    没有参数，返回一个结果 
    () -> {return 结果}

三、Stream API

Stream

1. filter(Predicate<? super T> predicate)
   过滤，参数是一个断言接口
   作用：用于过滤流中的元素，返回true留下，返回false去除
   返回：Stream类型
   
2. map(Function<? super T,? extends R> mapper)多个
   映射，参数是一个函数接口
   作用：用于对流中的元素进行改变等操作，比如加减乘除
   返回：Stream类型
   
3. flatMap(Function<? super T,? extends Stream<? extends R>>mapper)   
   扁平化映射，参数是一个函数接口
   作用：将所有元素都放入流中
   返回：Stream类型
4. forEach(Consumer<? super T> action)
   遍历，参数为消费者接口
   作用：用于遍历
   返回：void
5. distinct() 
   去重复，无需参数
   作用：用于去除流中的重复元素
   返回：Stream类型
6. count()
   统计个数，无需参数
   作用：用于返回流中的元素 个数
   返回：long类型
7. max(Comparator<? super T> comparator) 
   最大值，参数为比较器
   作用：用于返回流中最大的元素
   返回：Optional类型
   min(Comparator<? super T> comparator) 
   同理

数字流（例：IntStream）

IntStream intstream = IntStream.Of(1,2,3,4)
instream.max()   求最大值
instream.min()   求最小值
instream.average() 求平均值
instream.sum()    求和
注意：以上方法不可以向举例中一样连续调用
     原因见Stream api思想

收集流的结果

1. 将流转换为集合
   Collectors为收集器
   流.collect(Collectors.toList)   //转换为List集合
   流.collect(Collectors.toSet)    //转换为Set集合
2.限制收集个数
   limit(int num) num为收集的个数
   格式:
   流.limit(3).collect(Collectors.toList) //之收集前三个结果
3.分组
  流.collect(Collectors.groupingBy(函数接口))
  返回Map集合key是组名，value为组员的集合
  举例:
  创建集合学生集合名为student，集合中都是学生对象
  //按照性别分组
  Map<String, List<Student>> mp = students.stream().collect(Collectors.groupingBy((s) -> s.getSex() ));
  System.out.pringln(mp); //打印看结果
4.下游收集器
   流.collect(Collectors.groupingBy(函数接口，Collectors.counting()))
   工作方式：先分组，在求每组内元素个数
   返回Map集合，key为组名，value为每组的个数

四、并行计算

List<Integer> list = Arrays.aslist(1,2,3,4);
int sum = list.parallelStream().mapToInt(a -> a).sum();
//             获得集合的并行流   转为数字流        求和  
System.out.println(sum);
//结果为 10

五、Stream API中重要思想

流水线思想(Pipeline):
把流中的数据一个接一个的进行处理，即每个数据都会经过后续的filter、map等方法的依次调用。

在整个执行过程中，lambda表达式是懒惰的，不执行终结方法的话，不会触发lambda的执行。
终结方法： collect， sum， max， min 等

运算过程中不会改变原始集合，收集器会生成新的集合对象。