java 1.8 SteamAPI认识

一、关于Stream前言

Stream是 Java 8 的一大亮点，得尽快学会用哦，都2020年了还不会得我得抓紧了。
1、Stream关注的是对数据的运算，与CPU打交道；集合关注的是数据的存储，与内存打交道

2、
①Stream自己不会存储元素。
②Stream不会改变源对象。相反，他们会返回一个特有接口的新Stream.
③Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行
3、Stream执行流程
①Stream的实例化
②一系列的中间操作（过滤、映射、…）
③终止操作
4、说明：
4.1、一个中间操作链，对数据源的数据进行处理；
4.2、一旦执行终止操作，就执行中间操作链，并产生接口。之后，不会再被使用
参考B站视频（尚硅谷java高级语言）

二、操作Stream

（一）、实例化

//创建Stream方式一：通过集合
    @Test
    public void test1(){
        List<Integer> list = new ArrayList<>();
        list.add(123);
        //default Stream<E> stream():返回一个顺序流
        Stream<Integer> stream = list.stream();//串行流
        //default Stream<E> parallelStream():返回一个顺序流
        Stream<Integer> integerStream = list.parallelStream();//并行流
    }
    //创建Stream方式二：通过数组
    @Test
    public void test2(){
        int[] arr ={1,3,10};
        IntStream stream1 = Arrays.stream(arr);

        Integer[] integers ={3,8,1};
        Stream<Integer> stream2 = Arrays.stream(integers);
    }
    //创建Stream方式三：通过Stream的of();
    @Test
    public void test3(){
        Stream<Integer> stream = Stream.of(1,2,3,4,5,6);
    }
    //创建Stream方式四：创建无限流
    @Test
    public void test4(){
        //迭代
//        public static<T> Stream<T> iterate(final T seed,fianl UnarOperator<T> f)
        //遍历前10个偶数
        Stream.iterate(0,t->t+2).limit(10).forEach(System.out::println);
        //生成
//        public static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }

（二）中间操作

2.1 筛选与切片

不知所以然，但通过代码操作还是大概能知道其设计目的。

 //筛选与切片
    @Test
    public void test1(){
//        filter----接收Lambda，从流中排除某些元素
        List<Integer> list = new ArrayList<>();
        list.add(123);        list.add(345);        list.add(237);        list.add(912);
        Stream<Integer> stream = list.stream();
        stream.filter(integer -> integer>300).forEach(System.out::println);//两行代码查出了值大于300的数据
        System.out.println("*************************************************");
//        limit----截断流，使其元素不超过给定数量
        list.stream().limit(3).forEach(System.out::println);//数据的前3条
        System.out.println("*************************************************");
//        skip----跳过元素返回一个抛弃了前n个元素的流，若流中元素不满足n个，则返回一个空流，与limit形成互补
        list.stream().skip(3).forEach(System.out::println);
        System.out.println("*************************************************");
//        distinct----筛选，通过流所所生成元素的hashCode()和equals()去除重复元素
        list.add(456);        list.add(222);        list.add(101);        list.add(123);        list.add(1);        list.add(123);
        list.stream().distinct().forEach(System.out::println);
    }

2.2映射

 //映射
    @Test
    public void test2(){
//        map（Function f)----接收Lambda，将元素转换为其他形式或提取信息时，接收一个函数作为参数，该函数被应用到每个元素上，并将其映射成一个新的元素
        List<String> strings = Arrays.asList("aa", "bb", "cc", "dd", "eeee", "ffff");
        strings.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
//        练习1：
        strings.stream().map(str->str.length()>3).forEach(System.out::println);
        //练习2：
        Stream<Stream<Character>> streamStream = strings.stream().map(StreamAPITest1::fromStringToStream);
        streamStream.forEach(s->{
            s.forEach(System.out::println);
        });
        System.out.println("**************************************");
//        flatMap----接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接一个流
        Stream<Character> characterStream = strings.stream().flatMap(StreamAPITest1::fromStringToStream);
        characterStream.forEach(System.out::println);
    }
    //将字符串中的多个字符构成的集合转换为对于的Stream的实例
    public static Stream<Character> fromStringToStream(String str){
        ArrayList<Character> list = new ArrayList<>();
        for(Character c: str.toCharArray()){
            list.add(c);
        }
        return list.stream();
    }

两个映射操作有点向集合中add()和addall()方法，可以自己去体会。

2.3 排序

 //排序
    @Test
    public void test3(){
//        sorted() 自然排序 按照Comparable的方式,如果自定义类等需实现相关的Comparable接口
        List<String> list = Arrays.asList("aa","cc","bb");
        Stream<String> stream3 = list.stream().sorted();
        stream3.forEach(System.out::println);
//        sorted( Comparator com)定制排序
        List<Integer> arr = Arrays.asList(1,3,2,6,8,3,9);
        arr.stream().sorted((i1,i2)->{
            return Integer.compare(i1,i2);
        }).forEach(System.out::println);
    }

(三）终止操作

一切尽在代码中

3.1查找与匹配

 //查找与匹配
    @Test
    public void test1(){
//        allMatch----检查是否匹配所有元素
        List<Integer> list = Arrays.asList(1,3,2,6,8,3,9);
        boolean b = list.stream().allMatch(x -> x > 3);
        System.out.println(b);//false
//        anyMatch----检查是否有匹配至少一个元素
        boolean b1 = list.stream().anyMatch(x -> x == 3);
        System.out.println(b1);//true
//        noneMatch----检查是否没有匹配的元素
        boolean b2 = list.stream().noneMatch(x -> x > 10);
        System.out.println(b2);//true
//        findFirst----返回第一个元素
        Optional<Integer> first = list.stream().findFirst();
        System.out.println(first);//Optional[1]
//        findAny----返回当前流中的任意一元素
        Optional<Integer> any = list.stream().findAny();
        System.out.println(any);//Optional[1]
//        count-----返回流中元素的总数
        long count = list.stream().count();
        System.out.println(count);//7
//        max----返回流中最大值
        Optional<Integer> max = list.stream().max(Integer::compareTo);
        System.out.println(max);//Optional[9]
//        min----返回流中的最小值
        Optional<Integer> min = list.stream().min(Integer::compareTo);
        System.out.println(min);//Optional[1]
//        forEach----遍历流中的元素
    }

3.2归约

  //归约
    @Test
    public void test2(){
//        reduce(T identity,BinaryOperator)—可以将流中元素反复结合起来得到一个值，返回T
//        练习1：计算1-10的自然数的和
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Integer reduce = list.stream().reduce(0, Integer::sum);
        System.out.println(reduce);//55
//        reduce(BinaryOpreator)----可以将流中元素反复结合起来，返回Optional< T >
        Optional<Integer> reduce1 = list.stream().reduce((x, y) -> x + y);
        System.out.println(reduce1.get());//55
    }

3.3 收集

③收集
collect----将流转换为其他形式，接收一个Collector接口的实现，用于给Stream中元素做汇总的方法

Colloector 接口中方法的实现决定了如何对流执行手机操作（如收集到List、Set、Map中）但是Collectots实用类提供了很多静态方法，可以方便的创建常见收集器实例

这里暂时先不写了，可先参考Colloector接口相应的方法。