Stream

Stream

• 创建Stream -> 中间操作 -> 终止操作
• Stream是数据渠道,适用于数据源(集合,数组等)生成的元素序列
• Stream 自己不会储存元素
• Stream 不会改变源对象,相反,他们会返回一个持有结果的新Steam
• Stream操作是延迟执行的,这表示他们会等到需要结果的时候才回去执行

使用流程

创建Stream

    // 创建Stream的几种方式
    @Test
    public void test1(){
        //1. 创建Stream   通过Collection 集合提供的stream()或 parallelStream()
        List<String> stringList = new ArrayList<>();
        Stream<String> stream1  = stringList.stream();
        //2. 通过Arrays 中的静态方法stream()获取Stream() 获取数组刘
        String[] strings = new String[5];
        Stream<String> stringStream = Arrays.stream(strings);
        //3. 通过Stream类中的of()方法
        Stream<String> stringStream1 = Stream.of("aa","bb","cc");
        //4. 创建无限流
        Stream<Integer> integerStream =Stream.iterate(0,(x) ->x+2);
        stream1.limit(10).forEach(System.out::println);
        //5. 生成
        Stream.generate(() -> Math.random())
                .limit(5)
                .forEach(System.out::println);
    }

中间操作

    // 中间操作-筛选与切片
    /*
     filter(Predicate p)
    接收 Lambda ， 从流中排除某些元素。
    distinct()
    筛选，通过流所生成元素的 hashCode() 和 equals() 去 除重复元素
    limit(long maxSize)
    截断流，使其元素不超过给定数量。
    skip(long n)
    跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素 不足 n 个，则返回一个空流。与 limit(n) 互补
     */
    @Test
    public void test2(){
        List<String> strings = Arrays.asList(new String[]{"1", "2", "3", "1", "1"});
        // 过滤
        System.out.println("过滤");
        Stream<String> stringStream1 = strings.stream().filter((e) -> Integer.parseInt(e) > 1);
        stringStream1.forEach(System.out::println);
        // 限制
        System.out.println("限制");
        Stream<String> stringStream2 = strings.stream().limit(2);
        stringStream2.forEach(System.out::println);
        // 跳过
        System.out.println("跳过");
        Stream<String> stringStream3 = strings.stream().skip(3);
        stringStream3.forEach(System.out::println);
        // 去重
        System.out.println("去重");
        Stream<String> stringStream4 = strings.stream().distinct();
        stringStream4.forEach(System.out::println);
    }

    // 中间操作-映射
    /*
    map(Function f)
    接收一个函数作为参数，该函数会被应用到每个元 素上，并将其映射成一个新的元素。
    mapToDouble(ToDoubleFunction f)
    接收一个函数作为参数，该函数会被应用到每个元 素上，产生一个新的 DoubleStream。
    mapToInt(ToIntFunction f)
    接收一个函数作为参数，该函数会被应用到每个元 素上，产生一个新的 IntStream。
    mapToLong(ToLongFunction f)
    接收一个函数作为参数，该函数会被应用到每个元 素上，产生一个新的 LongStream。
    flatMap(Function f)
    接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
     */
    @Test
    public void test3(){
        List<String> strings = Arrays.asList(new String[]{"aaa", "bbb", "ccc", "aaa", "bbb"});
        // map
        System.out.println("map");
        strings.stream().map((e)->e.toUpperCase()).forEach(System.out::println);
        // map产生子流stream{stream,stream}
        System.out.println("map产生子流stream{stream,stream}");
        Stream<Stream<Character>> streamStream = strings.stream().map(Test1::getCharStream);
        streamStream.forEach((sm)->{sm.forEach(System.out::println);});
        // flatmap
        System.out.println("flatmap");
        strings.stream().flatMap(Test1::getCharStream).forEach(System.out::println);
    }
    public static Stream<Character> getCharStream(String str){
        List<Character> characterList = new ArrayList<>();
        for (Character c : str.toCharArray()) {
            characterList.add(c);
        }
        return characterList.stream();
    }

    // 中间操作-排序
    /*
    sorted()
    产生一个新流，其中按自然顺序排序
    sorted(Comparator comp)
    产生一个新流，其中按比较器顺序排序
     */
    @Test
    public void test4(){
        List<Integer> integers = Arrays.asList(new Integer[]{12, 95, -41, 36, 8});
        // 空参排序(默认从小到大)
        System.out.println("空参排序(默认从小到大)");
        integers.stream().sorted().forEach(System.out::println);
        // 自定义排序
        System.out.println("自定义排序");
        integers.stream().sorted((a,b)-> -Integer.compare(a,b)).forEach(System.out::println);
    }

###终止操作

    // 终止操作- 查找与匹配
    /*
    allMatch(Predicate p)
    检查是否匹配所有元素
    anyMatch(Predicate p)
    检查是否至少匹配一个元素
    noneMatch(Predicate p)
    检查是否没有匹配所有元素
    findFirst()
    返回第一个元素
    findAny()
    返回当前流中的任意元素
    count()
    返回流中元素总数
    max(Comparator c)
    返回流中最大值
    min(Comparator c)
    返回流中最小值
     */
    @Test
    public void test5(){
        List<Integer> integers = Arrays.asList(new Integer[]{12, 95, -41, 36, 8});
        // allMatch
        System.out.println("allMatch");
        System.out.println(integers.stream().allMatch((e) -> e.equals(12)));
        // anyMatch
        System.out.println("anymatch");
        System.out.println(integers.stream().anyMatch((e) -> e.equals(12)));
        // noneMatch
        System.out.println("noneMatch");
        System.out.println(integers.stream().anyMatch((e) -> e.equals(36)));
        // findFirst()
        System.out.println("findFirst");
        System.out.println(integers.stream().findFirst());
        // findAny()
        System.out.println("findAny");
        System.out.println(integers.stream().findAny());
        // count
        System.out.println("count");
        System.out.println(integers.stream().count());
        // max
        System.out.println("max");
        System.out.println(integers.stream().max(Integer::compareTo));
        // min
        System.out.println("min");
        System.out.println(integers.stream().min(Integer::compareTo));
    }

    // 归约
    /*
    reduce(T iden, BinaryOperator b)
    可以将流中元素反复结合起来，得到一个值。 返回 T
    reduce(BinaryOperator b)
    可以将流中元素反复结合起来，得到一个值。 返回 Optional<T>
     */
    @Test
    public void test6(){
        List<String> strings = Arrays.asList(new String[]{"aaa", "bbb", "ccc", "aaa", "bbb"});
        String str = strings.stream().reduce("",(x,y)->(x+y));
        System.out.println(str);
    }