02）JDK1.8 新特性学习 StreamAPI 并行流

StreamApiDemo01.java 

1.创建stream

2.中间操作（过滤、map）

3.终止操作

package com.wying.demo.StreamApi;

import org.junit.Test;

import java.util.*;
import java.util.function.UnaryOperator;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * description:Stream操作的三个步骤
 * Stream操作的三个步骤
 * 1.创建stream
 * 2.中间操作（过滤、map）
 * 3.终止操作
 *
 * jdk1.8对java.util.stream和我们之前解除的 java.io的流没关系
 * java.util.stream流就是一个对象可以反复使用 它是用于对集合Connection的操作
 * 引进的Lambda的函数式编程
 * 新特性Stream能够让用户以函数式的方式、更为简单的操纵集合等数据结构，并实现了用户无感知的并行计算
 *
 *
 * java.io的流是数据传输的 和流水一样,用过了就没了
 *
 * date: 2021/10/28
 * author: gaom
 * version: 1.0
 */
public class StreamApiDemo01 {
    @Test
    public void test01(){



        /**之前我们对集合，数据处理都是循环
         * for(int i=0;i<xxx.lengtn,i+=)  或者增强for循环 for(Sring a: strs)
         * jdk 1。8新提供的stream流来操作集合
         */
        //****************stream流创建**************//
        //ArrayList生成流方式list01.stream()
        List<String> list01=new ArrayList<>();
        //1.通过java集合类Collection接口的 stream()方法创建stream流
        Stream<String> stream01=list01.stream();


        //数组生成流方式Arrays.stream(ary01);
        Integer[] ary01=new Integer[10];
        //2.通过Arrays的静态方法stream()创建stream流
        Stream<Integer> stream02=Arrays.stream(ary01);

        //3.通过Stream的静态方法 of创建 stream流
        Stream<String> stream03=Stream.of("A","B","C","D");



       // Stream API提供了两个静态方法来从函数生成流：Stream.iterate和Stream.generate。这两个操作可以创建所谓的无限流：不像从固定集合创建的流那样有固定大小的流。

        //4.无限有序流iterate    0,(x)->x+2 是从0开始 每次+2
         //通过迭代函数，生成一个有序无限的Int数据流。（由于是无限流，一般都是配合limit来使用）。
        Stream<Integer> stream04=Stream.iterate(0,(x)->x+2);
        //无限流不做任何中断处理 直接执行stream04.forEach(System.out::print);
        // 将会无限循环执行输出024681012141618202224262830323436384042444648505254565860626466687072747678xxxxxxxxxx，每次增加2
        //直到内存溢出为止
        //  stream04.forEach(System.out::print);

        //控制无限流  跳到第3个循环之后 不包括第三个循环  取5条数据
        stream04.skip(3).limit(5).forEach(System.out::println); //  依次输出  6 8 10 12 14



        //无限无序流  generate （由于是无限流，一般都是配合limit来使用）。
        /** 和iterate不同的是，Stream.iterate可以通过seed入参 生成有序流
         *  而Stream.generate方法返回一个无限连续的无序流，其中每个元素由提供的供应商(Supplier)生成。generate方法用于生成常量流和随机元素流。
         * Math.random()表示每次执行这个函数生成一个随机数放入流中
         *
         */
        Stream<Double> stream05= Stream.generate(()->  Math.random());
        //执行forEach 把生成的随机数输出
        //无限流不做任何中断处理 直接执行stream05.forEach(System.out::println); 将会无限循环执行 直到内存溢出为止
       // stream05.forEach(System.out::println);
        //依次输出前10个产生的随机数
        stream05.skip(0).limit(10).forEach(System.out::println);



    }

    @Test
    public void test02(){



        //****************stream流中间操作**************//
        /**
         * 以前很多操作我们都是在 for循环里控制 stream都提供了相应的函数操作 简化了代码
         *
         *循环 forEach 为stream的终止操作 这里为了输出数据查看效果 最后都是使用的forEach函数输出值
         *
         * filter 过滤
         * 该操作会接受一个谓词（一个返回boolean的函数）作为参数，并返回一个包括所有符合谓词的元素的流。说白了就是给一个条件，filter会根据这个条件截取流中得数据。
         *
         * skip 舍弃 跳到指定位置
         * 该方法会返回一个扔掉了前面n个元素的流。如果流中元素不足n个，则返回一个空流。
         *
         *  limit 截取
         * 该方法会返回一个不超过给定长度的流。
         *
         * distinct 去重
         * 该操作会返回一个元素各异（根据流所生成元素的hashCode和equals方法实现）的流。
         *
         * sorted 排序
         * 对流中得数据进行排序，可以以自然序或着用Comparator 接口定义的排序规则来排序一个流。Comparator 能使用lambada表达式来初始化，还能够逆序一个已经排序的流。
         *
         *
         *
         */
        List<Integer> list06=new ArrayList<>();
        list06.add(6);
        list06.add(4);
        list06.add(8);
        list06.add(8);
        list06.add(9);
        list06.add(2);
        list06.add(11);


        //sorted 排序 如果对对象 entity排序 需要使用Comparator接口比较
        System.out.println("-----------正序-------------");
        list06.stream().sorted().forEach(System.out::println);
        System.out.println("------------倒序------------");
        list06.stream().sorted(Comparator.reverseOrder()).forEach(System.out::println);

        //filter 过滤   (x)->x==11 只保留 x==11的数据
        System.out.println("------------ 过滤 ------------");
        list06.stream().filter((x)->x==11).forEach(System.out::println); //输出11

        //skip(x) 舍弃 跳到指定位置
        System.out.println("------------ skip ------------");
        list06.stream().sorted(Comparator.reverseOrder()).skip(1).forEach(System.out::println);

        //limit(x) 该方法会返回一个不超过给定长度的流。
        System.out.println("------------ limit ------------");
        list06.stream().skip(1).limit(3).forEach(System.out::println);

        //distinct 去重 把重复的8去掉  根据流所生成元素的hashCode和equals方法实现
        System.out.println("------------ distinct ------------");
        list06.stream().distinct().forEach(System.out::println);

        //collect 收集  通过stream中间
        List<Integer> list07=list06.stream().skip(1).limit(3).collect(Collectors.toList());

        System.out.println("------------ 输出原list 流的所有操作不会改变list的结构  ------------");
        for(Integer i:list06){
            System.out.println("for:"+i);
        }


    }


    @Test
    public void test03(){



        //****************stream流终止操作**************//
        /**
         *
         *
         *
         *
         * 循环 forEach
         * 该操作会接受一个谓词（一个返回boolean的函数）作为参数，并返回一个包括所有符合谓词的元素的流。说白了就是给一个条件，filter会根据这个条件截取流中得数据。
         *
         * collect 收集
         * 从上面得代码已经可以看出来，collect是将最终stream中得数据收集起来，最终生成一个list，set，或者map。
         *
         * anyMatch
         * anyMatch方法可以回答“流中是否有一个元素能匹配到给定的谓词”。会返回一个boolean值。
         *
         * allMatch
         * allMatch方法和anyMatch类似，校验流中是否都能匹配到给定的谓词。
         *
         * noneMatch
         * noneMatch方法可以确保流中没有任何元素与给定的谓词匹配。
         *
         * findAny
         * findAny方法将返回当前流中的任意元素。
         *
         * findFirst
         * findFirst方法能找到你想要的第一个元素。
         *
         * 归约 reduce
         * 此类查询需要将流中所有元素反复结合起来，得到一个值，比如一个 Integer 。这样的查询可以被归类为归约操作（将流归约成一个值）。用函数式编程语言的术语来说，这称为折叠（fold），因为你可以将这个操
         * 作看成把一张长长的纸（你的流）反复折叠成一个小方块，而这就是折叠操作的结果。
         *
         *
         * 计算 min、max、count、average
         * 匹配 anyMatch、allMatch、noneMatch、findFirst、findAny
         * 汇聚 reduce
         *
         *
         */
        List<Integer> list06=new ArrayList<>();
        list06.add(6);
        list06.add(4);
        list06.add(8);
        list06.add(8);
        list06.add(9);
        list06.add(2);
        list06.add(11);




        //collect 收集  通过stream中间操作处理流的数据 生成一个新的集合
        System.out.println("-----------collect-------------");
        List<Integer> list07=list06.stream().skip(1).limit(3).collect(Collectors.toList());
        list07.stream().forEach(System.out::println);

        //循环 forEach 最常用的终止操作
        System.out.println("-----------forEach-------------");
        list06.stream().forEach(System.out::println);

        //查找匹配 anyMatch  如果list中存在数据等于100则返回true
        System.out.println("-----------anyMatch-------------");
        boolean b1=list06.stream().allMatch((x)->x==100);
        System.out.println(b1);

        //findAny 返回当前流中的任意元素。
        System.out.println("-----------findAny-------------");
        //Optional为jdk1.8提供的处理空指针的
        Optional<Integer>  opt1= list06.stream().findAny();
        System.out.println("opt1.get():"+opt1.get());


        // findFirst方法能找到你想要的第一个元素。
        System.out.println("----------- findFirst-------------");
        Optional<Integer>  opt2= list06.stream().findFirst();
        System.out.println("opt2.get():"+opt2.get());

        //归约 reduce
        //此类查询需要将流中所有元素反复结合起来，得到一个值，比如一个 Integer 。这样的查询可以被归类为归约操作（将流归约成一个值）。用函数式编程语言的术语来说，这称为折叠（fold），因为你可以将这个操
        //作看成把一张长长的纸（你的流）反复折叠成一个小方块，而这就是折叠操作的结果。
        System.out.println("----------- reduce-------------");
        //集合求和 0为基数
        int count=list06.stream().reduce(0,(x1, x2)->x1+x2);
        System.out.println("----------- 集合求和 reduce count:"+count+"-------------");

        //reduce 查找最大值Integer::max 查找最小值 Integer::min
        Optional<Integer> maxi=list06.stream().reduce(Integer::max);

        System.out.println("----------- 查找最大值 reduce maxi:"+maxi.get()+"-------------");


    }
}

2.并行流 parallelStream

 ParallelStream.java

package com.wying.demo.StreamApi;

import org.junit.Test;

import java.time.Instant;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * description:在jdk1.8新的stream包中针对集合的操作也提供了并行操作流和串行操作流。并行流就是把内容切割成多个数据块，
 * 并且使用多个线程分别处理每个数据块的内容。Stream api中声明可以通过parallel()与sequential()方法在并行流和串行流之间进行切换。
 * jdk1.8并行流底层是使用JAVA7新加入的Fork/Join框架：
 *
 * 这个用途很大 之前对数据处理 一个for循环太慢 要想快 最原始的不使用框架的话 得自己写代码开启新线程处理 还要控制集合的数据不要重复被取到等等
 * 或者使用jdk1.7的Fork/Join框架需要自己写很多代码，考虑逻辑
 * 现在stream已经内置了
 *
 * 不过在数据量不大的话不需要使用并行，数据量不大常规单线程效率还更快，stream和Fork/Join框架在数据量时使用效率提升明显，以空间换时间
 * 和服务器的CPU 环境都有关系，不过现在服务器CPU基本都是4核 8核的
 *
 * date: 2021/11/12
 * author: gaom
 * version: 1.0
 */
public class ParallelStream {
    @Test
    public void test01(){
        //创建一个有序无限流  从1 递增
        Stream<Integer> stream= Stream.iterate(1,x->x+1);
        //取前1000个数字 转为集合
        List<Integer> list06= stream.limit(100000000).collect(Collectors.toList());

        //串行流
        long a = Instant.now().toEpochMilli();
        System.out.println("*******串行流stream*********");
        Integer count1=list06.stream().reduce(0,(x1,x2)->x1+x2);
        long b = Instant.now().toEpochMilli();
        System.out.println("*******串行流stream*********计算 count1："+count1+" 耗时"+(b-a));
        //并行流
        System.out.println("*******并行流parallelStream*********");
        Integer count2=list06.parallelStream().reduce(0,(x1,x2)->x1+x2);
        long c = Instant.now().toEpochMilli();
        System.out.println("*******并行流parallelStream********计算 count2："+count2+" 耗时"+(c-b));
    }
}

集合数据量小时执行结果测试，串行流执行速度反而更快

集合数据量大时执行结果测试，并行流速度比串行流快了N倍