关于Stream流的操作，还有一小部分程序员只停留在IO阶段。因为该笔记时关于lambda表达式介绍的，所以不记录IO部分内容。
在日常开发中关于数组和集合操作是必不可少的，而Stream正是处理关于数组和集合的API。

Stream特性

• 不是数据结构，没有内部存储
• 不支持索引访问
• 延迟计算
• 支持并行
• 很容易生成数组或集合（List，Set）
• 支持过滤，查找，转换，汇总，聚合等操作

Stream运行机制

• Stream分为源，中间操作，终止操作。
• 流的源可以是一个数组，一个集合，一个生成器方法。
• 一个流可以有零个或多个中间操作，没有一个中间操作都会返回一个新的流，供下一个操作使用。
• 一个流只有一个终止操作。
• 只有当流遇到终止操作时，它的源才开始执行遍历操作，这就是为什么说Stream有延迟计算的特性。

Stream的创建

通过数组
通过集合
通过Stream.generate方法来创建
通过Stream.iterate方法来创建
通过其它API创建

package com.per.lambada;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class StreamTest {
    // 创建数组格式的流
    static void setArr1() {
        String arr[] = { "a", "b", "c", "d" };
        Stream<String> stream = Stream.of(arr);
    }
    // 创建List集合格式的流
    static void setArr2() {
        List<String> list = Arrays.asList("a", "b", "c", "d");
        Stream<String> stream = list.stream();
    }
    // 用generate创建(Supplier没输入有输出)
    static void setArr3() {
        Stream<Integer> stream = Stream.generate(() -> 1);
    }
    // 用iterate创建(UnaryOperator有输入有输出)
    static void setArr4() {
        Stream<Integer> stream = Stream.iterate(1, x -> x + 1);
    }
}

流的中间操作

过滤filter
去重distinct
排序sorted
截取limit、skip
转换map、flatMap
其他peek

流的终止操作

循环forEach
计算min、max、count、average
匹配anyMatch、allMatch、noneMatch、findFirst、findAny
汇聚reduce
收集器toArray、collect

package com.per.lambada;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamTest {
    public static void main(String[] args) {
        //中间操作：filter；终止操作：forEach
        Arrays.asList(1,2,3,4,5,6,7).stream().filter(x->x%2==0).forEach(System.out::println);
        
        //中间操作：filter,mapToInt；终止操作：sum
        int sum = Arrays.asList(1,2,3,4,5,6,7).stream().filter(x->x%2==0).mapToInt(x->x).sum();
        System.out.println("sum:"+sum);
        
        //中间操作：max；终止操作：get
        int max = Arrays.asList(1,2,3,4,5,6,7).stream().max((a,b)->a-b).get();
        System.out.println("max:"+max);
        
        //中间操作：min；终止操作：get
        int min = Arrays.asList(1,2,3,4,5,6,7).stream().min((a,b)->a-b).get();
        System.out.println("min:"+min);
        
        Optional<Integer> op = Arrays.asList(1,2,3,4,5,6,7).stream().filter(x->x%2==0).findAny();
        System.out.println("查找任意元素"+op.get());
        
        int first=Arrays.asList(12,21,13,44,5,6,27).stream().sorted((a,b)->b-a).findFirst().get();
        System.out.println("由大到小排序后第一个元素是"+first);
        
        Object obj=Arrays.asList("ab","c","defg","hij","klm","n","opqrs").stream().sorted((a,b)->b.length()-a.length());
        System.out.println((String)obj.toString());
        
        // 将1-50放进list集合中
        List<Integer> li = Stream.iterate(1, x->x+1).limit(50).collect(Collectors.toList());
        
        Object[] a=Arrays.asList(1,2,3,4,5,6,7,8,2,3,4,5).stream().distinct().toArray();
        
        // 去重可以使用distinct或使用Set集合的特性实现
        Set<Integer> set=Arrays.asList(2,3,4,5,6,7,8,2,3,4,5,1).stream().collect(Collectors.toSet());
        System.out.println(set);
        
        String str ="11,22,33,44,55";
        int num =Stream.of(str.split(",")).mapToInt(x->Integer.valueOf(x)).sum();
        System.out.println(num);
    }
}