初识stream流

stream流是对数组操作进行简化的工具,stream流的主要思想和工厂流水线加工一样,在流水线上对数据进行操作,一般过程就是先获取Stream流,进行中间操作,连续多个中间操作结束后,进行终结操作,终结操作结束后,就等于流就结束了,不能在对流进行操作.

获取Stream流的方法:一般我们是用stream操作集合,但是数组和相同类型的多个数据我们以为是可以操作的.

单列集合:单列集合一般来说我们都是通过直接调用java提供好的stream方法,List.stream()/Set.stream(),这样我们一般就直接获取到一个stream流;

双列集合:双列集合map我们是没有直接获取stream流的方法,我们有两种方法:1.先通过Map.keyset()先获取到所有键储存在set集合中,然后在通过键的set集合获取到stream流,Map.keySet().stream();2.通过Map.entrySet()获取到每一个键值对对象的集合,然后根据键值对的集合,获取stream流,Map.entrySet().stream();

数组:我们利用数组工具类Arrays中的stream方法获取,Arrays.stream(arr)参数就是我们需要操作的数组.

相同类型的多个数据:我们要使用到可变参数,以及Stream.of()方法,Stream.of(参数类型... 变量名)

public class MyStream02 {
    public static void main(String[] args) {
        //调用方法
//        listSteam();
        mapStream01();
//        mapStream02();
//        arrStream();
//        StreamStream();
    }

    private static void StreamStream() {
        //利用可变参数将数据传递到strea流中
        Stream.of(77, 88, 99, 00)
                //遍历数据
                .forEach(i ->
                        System.out.println(i));
    }

    private static void arrStream() {
        //创建集合静态初始化
        int[] arr = {1, 2, 3, 4, 5, 6};
        //创建stream流,将数组元素放在流上
        Arrays.stream(arr)
                //遍历数据,并打印
                .forEach(i ->
                        System.out.println(i));
    }

    private static void mapStream02() {
        //创建map集合,利用批量添加元素
        HashMap<String, Integer> map = new HashMap<>(
                Map.of("张三", 18,
                        "李四", 16, "王五", 20));
        //获取所有的键值对对象,放在集合中
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        //将键值对对象集合所有数据放在流上,遍历数据,打印
        entrySet.stream().forEach((s) ->
                System.out.println(s));
    }

    private static void mapStream01() {
        //创建map集合,利用批量添加元素
        HashMap<String, Integer> map = new HashMap<>(
                Map.of("张三", 18, "李四", 16,
                        "王五", 20));
        //获取所有的键,储存在集合中
        Set<String> key = map.keySet();
        //将键的集合中所有键放在流上,遍历打印
        key.stream().forEach((s) -> {
            Integer value = map.get(s);
            System.out.println(s+"---"+value);});
    }

    private static void listSteam() {
        //创建ArrayList集合,批量添加元素
        ArrayList<String> list = new ArrayList<>(List.of("aaa", "bbb", "ccc"));
        //创建流对象,将元素放上流上,遍历并打印
        list.stream().forEach(s -> System.out.println(s));
    }
}

获取到stream流后,我们需要对流中数据进行操作,中间操作一般常用方法有:
    filter(lambda):过滤不符合条件数据,留下符合条件的,里边的参数就是你要筛选的条件,一般使用lambda表达式形式
    limit(long l):截取l个数据
    skip(long l):跳过l个的数据
    concat(Stream a,Stream b):将a,b两个流合并为一个
    distinct():去除流中重复数据

public class MyStream03 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> list = new ArrayList<>();
        //添加元素
        list.add("张三丰");
        list.add("王二麻子");
        list.add("刘老三");
        list.add("张良");
        list.add("张无忌");
        list.add("李三丰");
        list.add("张三丰");
//      调用方法
//        filter(list);
//        limit(list);
//        skip(list);
//        concat(list);
//        distinct(list);
    }

    private static void distinct(ArrayList<String> list) {
        //distinct()去除流中重复数据,以依赖hashCode和equals
        //添加元素
        list.add("张三丰");
        list.add("张三丰");
        list.add("张三丰");
        list.add("张三丰");
        list.add("张三丰");
        list.stream().distinct().forEach(s -> System.out.println(s));
    }

    private static void concat(ArrayList<String> list) {
        //创建集合
        ArrayList<String> list2 = new ArrayList<>();
        //添加元素
        list2.add("张三丰");
        list2.add("王二麻子");
        list2.add("刘老三");
        list2.add("张良");
        list2.add("张无忌");
        list2.add("李三丰");
        list2.add("张三");
        //concat(Stream a,Stream b)将a,b两个流合并为一个流
//        Stream<String> stream1 = list.stream();
//        Stream<String> stream2 = list2.stream();
//        Stream<String> stream3 = Stream.concat(stream1, stream2);
//        stream3.forEach(s-> System.out.println(s));
        Stream.concat(list.stream(), list2.stream()).forEach(s ->
                System.out.println(s));
    }

    private static void skip(ArrayList<String> list) {
        //skip(long n)跳过指定个数数据
        list.stream().skip(4).forEach(e -> System.out.println(e));
    }

    private static void limit(ArrayList<String> list) {
        //截取指定个数的元素
        list.stream().limit(2).forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
    }

    private static void filter(ArrayList<String> list) {
        //过滤掉不符合条件的元素,留下符合条件
        //匿名内部类
//        list.stream().filter(new Predicate<String>() {
//            @Override
//            public boolean test(String s) {
//               return s.startsWith("张");
//            }
//        }).forEach(s-> System.out.println(s));
        //lambda表达式
        list.stream().filter(e ->
                e.startsWith("张")).forEach(s ->
                System.out.println(s));
    }
}

一般使用到的终结操作:

forEach遍历打印

forEach(s->System.out.println(s))

count:计数

对流中的数据进行计数

中间操作一般我们是不会改变原来的数据源的,只是将数据源中的数据复制一份放在流上,流消失那么流上的数据也就消失了,所以我们要使用流中操作后的数据就需要一个集合结束,

我们使用collection(Collector collertor)接收,参数是collector类型,我们就需要使用collectors工具类

collectors.toList()创建list集合并将数据存入,collectors.toSet()创建Set集合并将数据存入,

collectors.toMap(fonction key,fouction valve)创建Map集合并将数据存入,

public class MyStream05 {
    public static void main(String[] args) {
        //创建list集合,添加数据
        ArrayList<Integer> list1 = new ArrayList<>(
                List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
        );
        //将strea流中数据收集在list集合中
        List<Integer> list = list1.stream().filter(s -> s % 2 == 0).collect(Collectors.toList());
        System.out.println(list);
        //将strea流中数据收集在Set集合中
        Set<Integer> set = list1.stream().filter(s -> s % 2 == 0).collect(Collectors.toSet());
        System.out.println(set);
        //创建集合,存储数据
        ArrayList<String> list3 = new ArrayList<>();
        list3.add("lisi,23");
        list3.add("zhangsan,24");
        list3.add("wangwu,25");
        //将stream流中数据收集在map集合中
        System.out.println(list3.stream().collect(Collectors.toMap(s -> s.split(",")[0], s -> s.split(",")[1])));

    }
}