JDK1.8 Stream

定义

stream是一组用来处理数组、集合的API

为什么jdk1.8要引入函数式编程

1、代码简洁，函数式编程代码简洁且意图明确，使用sream可以告别for循环
2、多核友好，java函数式编程使并行程序编写简单，只需要调用parallel方法

Stream特点

1、不是数据结构，没有内部存储
2、不支持索引访问（因为没有内部存储）
3、延迟计算，不调用终止操作不会执行
4、支持并行
5、很容易生成数组和集合
6、支持过滤、转换、汇总、集合等操作

stream使用

Stream分为源source、中间操作、终止操作
一个流可以有多个中间操作，但只会有一个最终操作，只有执行最终操作的时候才会计算

//Stream创建
        //通过数组方式
        Stream<String> aa = Stream.of("aa", "ss", "ff");
        //通过集合生成
        List<String> list1 = Arrays.asList("ww", "ee", "rr", "tt");
        Stream<String> stream = list1.stream();
        /*  通过generator生成
            generate(Supplier<T> s)
            返回无限顺序无序流，其中每个元素由提供的 Supplier 。
            Supplier 一个输出
         */
        Stream<Integer> generate = Stream.generate(() -> 1);
        //因为无限，需要使用limit限制长度
        generate.limit(10).forEach(System.out::println);

        /**
         * 通过iterater生成
         *iterate(T seed, UnaryOperator<T> f)
         * 返回有序无限连续 Stream由函数的迭代应用产生 f至初始元素 seed ，产生 Stream包括 seed ， f(seed) ， f(f(seed)) ，等
         UnaryOperator 一个输入一个输出，相同类型
         */
        Stream<Integer> iterate = Stream.iterate(1, (x) -> x + 1);
        iterate.limit(10).forEach(System.out::println);
        /**
         * 其他方式
         *
         */
        String str = "abcdef";
        IntStream chars = str.chars();
        chars.forEach(System.out::println);

 //求出结果集中所有偶数的和 stream没有sum方法，需要转为IntStream
    static void sum(){
        Stream<Integer> stream = Arrays.asList(1, 3, 4, 6, 8, 9).stream().filter((x) -> x % 2 == 0);
        IntStream intStream = stream.mapToInt(x -> x);
        System.out.println(intStream.sum());
    }
    //求集合中的最大值
    static void max(){
        System.out.println(Arrays.asList(1, 3, 4, 6, 8, 9).stream().max((a, b) -> a - b).get());
    }
     //求集合的最小值
    static  void min(){
        System.out.println(Arrays.asList(23, 7, 3, 5, 6, 7).stream().min((a, b) -> a - b).get());
    }
    //获取最大值和最小值但是不使用min和max方法
    static void sorted(){
        List<Integer> list = Arrays.asList(33, 55, 66, 23, 68, 88);
        System.out.println(list.stream().sorted().findFirst().get());
        System.out.println(list.stream().sorted((a, b) -> b - a).findFirst().get());
        List<String> list1 = Arrays.asList("java", "c#", "python", "scala");
        list1.stream().sorted().forEach(System.out::println);
        list1.stream().sorted((a,b)->a.length()-b.length()).forEach(System.out::println);
    }
    //想将集合中的元素进行过滤同时返回一个集合对象
    static void filter(){
        List<Integer> list = Arrays.asList(1,2, 3,4, 5, 6);
        Object[] objects = list.stream().filter(a -> a % 2 == 0).toArray();
        for (Object object : objects) {
            System.out.println(object);
        }
        List<Integer> collect = list.stream().filter(a -> a % 2 == 0).collect(Collectors.toList());
        collect.forEach(System.out::println);
    }

    //去重操作
    static void distinct(){
        List<Integer> list = Arrays.asList(1,2, 3,4, 5, 67,3,4);
        list.stream().distinct().forEach(System.out::println);
        list.stream().collect(Collectors.toSet()).forEach(System.out::println);
    }

    //打印20-30这样的集合数据
    static void limit(){
        Stream.iterate(1,x->x+1).limit(30).skip(20).forEach(System.out::println);
    }
    /*创建一组自定义对象
    map(Function<? super T,? extends R> mapper)
    返回由给定函数应用于此流的元素的结果组成的流。
    mapToInt(ToIntFunction<? super T> mapper)
返回一个 IntStream ，其中包含将给定函数应用于此流的元素的结果。
    */
    static void map(){
        String str ="11,22,33,44,55";
        Stream.of(str.split(",")).mapToInt(new ToIntFunction<String>() {
            @Override
            public int applyAsInt(String value) {
                return Integer.valueOf(value);
            }
        }).forEach(System.out::println);
        Stream.of(str.split(",")).mapToInt((x)->Integer.valueOf(x)).forEach(System.out::println);
        Stream.of(str.split(",")).mapToInt(Integer::valueOf).forEach(System.out::println);
        Stream.of(str.split(",")).forEach(System.out::println);

        String str2 = "java,scala,python";
        Stream.of(str2.split(",")).map(x->new Person(x)).forEach(System.out::println);
        Stream.of(str2.split(",")).map(Person::new).forEach(System.out::println);
        Stream.of(str2.split(",")).map(x->Person.build(x)).forEach(System.out::println);
        Stream.of(str2.split(",")).map(Person::build).forEach(System.out::println);
    }

    //将str中的每一个数值都打印出来，同时算出最终的求和结果 peek方法主要用于调试
    static void peek(){
        String str ="11,22,33,44,55";
        System.out.println(Stream.of(str.split(",")).mapToInt(Integer::valueOf).peek(x -> System.out.println(x)).sum());
    }