Stream流基础教程

1、Stream介绍

Stream是一组用来处理数组、集合的API，使用stream接口从此告别for循环

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

2、Stream的创建方式

• 通过数组
• 通过集合
• 通过Stream.generate方法
• 通过Stream.iterate方法
• 其他API

3、Stream的常用API

中间操作

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

终止操作

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

4、Stream的习题练习

package Io.com.lian.stream;

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

public class StreamDemo {

    //数组生成stream
    static void gen1(){
        String[] str = {"a","b","c","d"};
        Stream<String> stream = Stream.of(str);
        stream.forEach(System.out::println);
    }

    //list生成stream
    static void gen2(){
        List<String> list = Arrays.asList("a", "b", "c", "d");
        Stream<String> stream = list.stream();
        stream.forEach(System.out::println);
    }

    //generate
    static void gen3(){
        Stream<Integer> generate = Stream.generate(() -> 1);
        generate.limit(5).forEach(System.out::println);
    }

    //
    static void gen4(){
        Stream<Integer> iterate = Stream.iterate(2, x -> x + 1);
        iterate.limit(5).forEach(System.out::println);
    }

    static void gen5(){
        String str = "gjdsggn";
        IntStream chars = str.chars();
        chars.forEach(System.out::println);
    }

    public static void main(String[] args) {
//        StreamDemo.gen1();
//        gen1();
//        gen2();
//        gen3();
//        gen4();
//        gen5();
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 50);
        //中间操作，如果调用方法后返回结果是stream对象，就意味着是一个中间操作
        list.stream().filter((x) -> x % 2 == 0).forEach(System.out::println);
        //偶数求和
        int sum = list.stream().filter((x) -> x % 2 == 0).mapToInt(x -> x).sum();
        //求出结果集中所有偶数的和
        System.out.println(sum);

        //求集合中的最大值
        Optional<Integer> max = list.stream().max((a, b) -> a - b);
        System.out.println(max.get());

        //求集合中的最小值
        Optional<Integer> min = list.stream().min((a, b) -> a - b);
        System.out.println(min.get());

        //获取偶数的个数
        Optional<Integer> any = list.stream().filter(x -> x % 2 == 0).findAny();
        System.out.println(any.get());

        //获取偶数的第一个数
        Optional<Integer> first = list.stream().filter(x -> x % 2 == 0).findFirst();
        System.out.println("获取偶数的第一个数: "+first.get());

        // java.util.stream.ReferencePipeline$2@b4c966a
        Stream<Integer> integerStream = list.stream().filter(x -> x % 2 == 0);
        System.out.println(integerStream);

        System.out.println("------------------------------");

        Stream<Integer> stream1 = list.stream().filter(x -> {
            System.out.println("运行代码");
            return x % 2 == 0;
        });
        System.out.println(stream1);  //中间操作 不会打印 运行代码
        System.out.println(stream1.findFirst().get());  //终止操作 会打印 运行代码

        //获取 最大值和最小值，但是不使用min和max方法
        Optional<Integer> min2 = list.stream().sorted().findFirst();
        System.out.println("min: "+min2.get());

        //获取最大值
        Optional<Integer> max2 = list.stream().sorted((a, b) -> b - a).findFirst();
        System.out.println("max: "+max2.get());

        //将列表最小值和最大值排列顺序
        System.out.println(Arrays.asList("lisi", "zhangsan", "wangwu", "mazi").stream().sorted());
        Arrays.asList("lisi", "zhangsan", "wangwu", "mazi").stream().sorted().forEach(System.out::println);
        Arrays.asList("lisi", "zhangsan", "wangwu", "mazi").stream().sorted((a,b)->a.length()-b.length()).forEach(System.out::println);

        //将集合中的元素过滤同时返回一个集合对象
        //遍历集合里的每一个偶数
        list.stream().filter(x->x%2==0).forEach(System.out::println);

        //将集合过滤出来再放到集合里遍历
        List<Integer> collect = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
        collect.forEach(System.out::println);

        //去重操作
        Arrays.asList(1,2,3,4,5,1,2,3).stream().distinct().forEach(System.out::println);
        //用set去重
        Arrays.asList(1,2,3,4,5,1,2,3).stream().collect(Collectors.toSet()).forEach(System.out::println);

        //打印20到30的集合数据
        Stream.iterate(1,x->x+1).limit(50).skip(20).limit(10).forEach(System.out::println);

        //求和
        String str = "11,12,13,14,15";
        String[] split = str.split(",");
        int suma = 0;
        for (String s : split) {
            Integer integer = Integer.valueOf(s);
            suma+=integer;
        }
        System.out.println("sum is: "+suma);
        
        //stream流求和
        String string = "11,12,13,14,15";
        String[] arr = string.split(",");
        //将数组转为流，类型转为int，在求和
        //System.out.println(Stream.of(arr).mapToInt(x -> Integer.valueOf(x)).sum());
        //System.out.println(Stream.of(arr).map(x -> Integer.valueOf(x)).mapToInt(x -> x).sum());
        //System.out.println(Stream.of(arr).mapToInt(Integer::valueOf).sum());
        System.out.println(Stream.of(arr).map(Integer::valueOf).mapToInt(x -> x).sum());

        String str2 = "java,paython,c";
        String[] arr2 = str2.split(",");
        //Stream.of(arr2).map(x->new Person(x)).forEach(System.out::println);
        //Stream.of(arr2).map(Person::new).forEach(System.out::println);
        //Stream.of(arr2).map(Person::build).forEach(System.out::println);
        Stream.of(arr2).map(x->Person.build(x)).forEach(System.out::println);

        //将字符串中的每一个数值都打印出来，同时求和
        System.out.println(Stream.of(arr).peek(System.out::println).mapToInt(Integer::valueOf).sum());

    }
}