• Stream流


    Stream流

    Stream API可以极大提高Java程序员的生产力,让程序员写出高效率、干净、简洁的代码。这种风格将要处理的元素集合看作一种流, 流在管道中传输, 并且可以在管道的节点上进行处理, 比如筛选, 排序,聚合等。元素流在管道中经过中间操作(intermediate operation)的处理,最后由最终操作(terminal operation)得到前面处理的结果。

    对比:

    package com.py.Stream;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class DemoStreamFilter {
        public static void main(String[] args) {
            ArrayList<String> list = new ArrayList<>();
            list.add("张三丰");
            list.add("霍元甲");
            list.add("张无忌");
            list.add("杨过");
            list.add("张文");
    //      过滤获得一张开头的名字
            ArrayList<String> nlist = new ArrayList<>();
            for (String i :
                    list) {
                if (i.startsWith("张")){
                    nlist.add(i);
                }
            }
    
    //      循环得到字符长度为3的名字
            for (String i :
                    nlist) {
    
                if (i.length()==3){
                    System.out.println(i);
                }
            }
        }
    }
    
    
    package com.py.Stream;
    
    import java.util.ArrayList;
    
    public class DemoStreamFilter01 {
        public static void main(String[] args) {
            ArrayList<String> list = new ArrayList<>();
            list.add("张三丰");
            list.add("霍元甲");
            list.add("张无忌");
            list.add("杨过");
            list.add("张文");
            //      过滤获得一张开头的名字
            //      循环得到字符长度为3的名字
            //      遍历
            list.stream()
                    .filter(name->name.startsWith("张"))
                    .filter(name->name.length()==3)
                    .forEach(naem-> System.out.println(naem));
        }
    }
    
    

    获取Stream流的方法

    • 所有的Collection集合(单列集合)都可以通过Strem方式获得流

      • java.util.Interface Collection

      ​ default Stream stream() 返回以此集合作为源的顺序 Stream 。

    • Stream接口的静态方法of可以获得数组对应的流

      • java.util.stream.Interface Stream

    集合间的关系

    实例

    package com.py.Stream;
    
    import java.util.*;
    import java.util.stream.Stream;
    
    public class DemoGetStream {
        public static void main(String[] args) {
            //把ArraryList转换为流
            ArrayList<String> list = new ArrayList<>();
            Stream<String> stream01 = list.stream();
    
            //将set转化为流
            Set<String> set = new HashSet<>();
            Stream<String> stream02 = set.stream();
    
            //Map转化为stream流
            Map<String,String> map = new HashMap<>();
                //将键转化为流
            Stream<String> stream03 = map.keySet().stream();
                //将值转化为流
            Stream<String> stream04 = map.values().stream();
                //获取键值对
            Stream<Map.Entry<String, String>> stream05 = map.entrySet().stream();
    
    
            //将数组转化为流
            Stream<Integer> stream06 = Stream.of(1, 2, 3, 4, 5, 6);
    			//int类型
            Integer[] integer = {1,2,3,4,5,6};
            Stream<Integer> stream07 = Stream.of(integer);
    			//String类型
            String [] str = {"ni","aef","zsdf","dsfg"};
            Stream<String> stream08 = Stream.of(str);
    
    
        }
    }
    
    

    常用方法

    常用的方法分为两类:

    • 延迟方法:返回值仍然是Stream流接口的方法,支持链式调用
    • 终结方法: 返回值类型不再是stream流接口的方法,因此不再支持类似的链式调用

    forEach

    返回值 方法 描述
    void forEach(Consumer<? super T> action) 对此流的每个元素执行操作。【接口方法】

    Consumer 接口中包含抽象方法void accept(T t),消费一个指定泛型的数据。

    ​ T:流中的元素类型

    Filter

    返回值 方法 描述
    Stream<T> filter(Predicate<? super T> predicate) 返回由与此给定谓词匹配的此流的元素组成的流。

    Predicate:函数式接口,可以使用lambda表达式对数据进行过滤。

    ​ 抽象方法 test(T t)

    Map

    返回值 方法 描述
    <R> Stream<R> map(Function<? super T,? extends R> mapper) 返回由给定函数应用于此流的元素的结果组成的流。【映射为其他类型】

    Function:函数式接口,可以使用lambda表达式进行映射

    ​ 抽象方法:R apply (T);

    Count

    返回值 方法 描述
    long count() 返回此流中的元素数。

    此方法是一个终结方法,统计流中元素个数,调用后不能继续使用。

    Limit

    返回值 方法 描述
    Stream<T> limit(long maxSize) 返回由此流的元素组成的流,截短长度不能超过 maxSize

    截取前maxSize位的元素,组成一个新的流。

    Skip

    返回值 方法 描述
    Stream<T> skip(long n) 在丢弃流的第一个 n元素后,返回由该流的 n元素组成的流。

    丢弃前n个元素后,追成一个新的流。

    Concat

    返回值 方法 描述
    static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) 创建一个懒惰连接的流,其元素是第一个流的所有元素,后跟第二个流的所有元素。

    练习

    package com.py.Stream;
    
    import java.util.stream.Stream;
    
    public class DemoStreamMethor {
        public static void main(String[] args) {
            Stream<String> stream = Stream.of("张三", "李四", "王五", "刘六", "田七");
    //        filter(stream);
    //        count(stream);
    //        limit(stream);
    //        skip(stream.skip(3));
        }
    
        private static void skip(Stream<String> skip) {
            skip
                    .forEach(name -> {
                        System.out.println(name);
                    });
        }
    
        private static void limit(Stream<String> stream) {
            skip(stream.limit(3));
        }
    
        private static void count(Stream<String> stream) {
            System.out.println(stream.count());
        }
    
        private static void filter(Stream<String> stream) {
            stream.filter((String name)->{ return name.startsWith("张");})
                    .forEach((name->{System.out.println(name);}));
        }
    }
    
    

    实例

    package com.py.Stream;
    
    import java.util.ArrayList;
    import java.util.stream.Stream;
    
    public class DemoTest {
        public static void main(String[] args) {
            ArrayList<String> one = new ArrayList<>();
            one.add("迪丽热巴");
            one.add("宋远桥");
            one.add("迪丽热巴");
            one.add("苏星河");
            one.add("石破天");
            one.add("老子");
    
            Stream<String> oneStream = one.stream().filter(name -> {
                return name.length() == 3;
            }).limit(3);
    
    
    
            ArrayList<String > two = new ArrayList<>();
            two.add("古力娜扎");
            two.add("张无忌");
            two.add("赵丽颖女");
            two.add("张三丰");
            two.add("赵四");
            two.add("汪远");
            two.add("铃木爱理");
    
            Stream<String> twoStream = two.stream().filter(name -> {
                return name.length() == 4;
            }).skip(1);
    
            Stream.concat(oneStream,twoStream).map(name->{return new Person(name);}).forEach(p->{
                System.out.println(p);
            });
    
        }
    }
    
    
  • 相关阅读:
    半夜删你代码队 Day6冲刺
    半夜删你代码队 Day5冲刺
    半夜删你代码队 Day4冲刺
    半夜删你代码队 Day3冲刺
    Scrum 冲刺博客集合
    团队项目6——复审与事后分析
    Alpha阶段项目复审
    事后Postmortem会议
    团队作业5-测试与发布
    Scrum 冲刺第七天
  • 原文地址:https://www.cnblogs.com/yuknight/p/13780274.html
Copyright © 2020-2023  润新知