25.Stream流（基础班完结）

最新推荐文章于 2023-06-14 20:08:37 发布

RainyRarity

最新推荐文章于 2023-06-14 20:08:37 发布

阅读量112

点赞数

分类专栏：学习笔记文章标签： java

本文链接：https://blog.csdn.net/twilight___/article/details/111289434

版权

学习笔记专栏收录该内容

46 篇文章 1 订阅

订阅专栏

本文详细介绍了Java Stream流的概念，包括如何生成流、常用的中间操作如filter、limit、skip等，以及终结操作如forEach、count。此外，还通过实例展示了Stream流在处理集合数据时的实践应用，如过滤男演员和女演员的条件并整合结果，以及如何使用collect方法将流数据收集到集合中。

摘要由CSDN通过智能技术生成

1.Stream流

1.1 体验Stream流

需求：按照下面的要求完成集合的创建和遍历
① 创建一个集合，存储多个字符串元素
② 把集合中所有以“R”开头的元素存储到一个新的集合
③ 把“R”开头的集合中的长度为6的元素存储到一个新的集合
④ 遍历上一步得到的集合

使用Stream流的方式完成过滤操作
    array.stream().filter(s -> s.startsWith("R")).filter(s -> s.length() == 6).forEach(System.out::println);
    直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：生成流、过滤R开头、过滤长度为6、逐一打印
    Stream流把真正的函数式编程风格引入到Java中

public class StreamDemo1 {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<String>();
        array.add("Rarity");
        array.add("TwilightSparkle");
        array.add("RainbowDash");
        array.add("FlutterShy");
        array.add("AppleJack");
        array.add("PinkiePie");
        ArrayList<String> rList = new ArrayList<>();
        for(String s : array){
            if(s.startsWith("R")){
                rList.add(s);
            }
        }
        ArrayList<String> finallyList = new ArrayList<>();
        for(String s : rList){
            if(s.length() == 6 ){
                finallyList.add(s);
            }
        }
        for(String s : finallyList){
            System.out.println(s);
        }
        System.out.println("--------");
        //利用Stream流来进行改进
        array.stream().filter(s -> s.startsWith("R")).filter(s -> s.length() == 6).forEach(s -> System.out.println(s));
        array.stream().filter(s -> s.startsWith("R")).filter(s -> s.length() == 6).forEach(System.out::println);
    }
}

1.2 Stream流的生成方式

Stream流的使用
● 生成流
        通过数据源(集合，数组等)生成流
        list.stream()
● 中间操作
        一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个操作使用
        filter()
● 终结操作
        一个流只能有一个终结操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作
        forEach()


Stream流的常见生成方式
● Collection体系的集合可以使用默认方法stream()生成流
        default Stream< E> stream()
● Map体系的集合间接的生成流
● 数组可以通过Stream接口的静态方法of(T…values)生成流

public class generateStream {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Stream<String> listStream = list.stream();

        Set<String> set = new HashSet<>();
        Stream<String> setStream = set.stream();

        //Map体系的集合间接的生成流
        Map<String,Integer> map = new HashMap<>();
        //键的生成流
        Stream<String> keyStream = map.keySet().stream();
        //值的生成流
        Stream<Integer> valueStream = map.values().stream();
        //键值对对象的生成流
        Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();

        //数组可以通过Stream接口的静态方法of(T...values)生成流
        String[] strArray = {"Rarity","TwilightSparkle","RainbowDash"};
        Stream<String> strArrayStream = Stream.of(strArray);
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6, 7);
    }
}

1.3 Stream流的常见中间操作方法

● Stream< T> filter(Predicate predicate)：用于对流中的数据进行过滤
Predicate接口中的方法 boolean test(T t)：对给定的参数进行判断，返回一个布尔值
依赖于Predicate接口中的方法boolean test(T t)来对数据进行判断过滤

public class OperateStream {
    public static void main(String[] args) {
        ArrayList<String> list= new ArrayList<>();
        list.add("Rarity");
        list.add("TwilightSparkle");
        list.add("RainbowDash");
        list.add("PinkiePie");
        list.add("AppleJack");
        list.add("FlutterShy");
        list.add("SunsetShimmer");
        list.add("StarlightGlimmer");
        list.add("Spike");
        //需求1：把list集合中以S开头的元素在控制台输出
        list.stream().filter(s -> s.startsWith("S")).forEach(s -> System.out.println(s));
        System.out.println("---------");
        //需求2：把list集合中长度为13的元素在控制台输出
        list.stream().filter(s -> s.length() ==13).forEach(s -> System.out.println(s));
        //需求3：把list集合中以S开头的，长度为13的元素在控制台输出
        System.out.println("--------");
        list.stream().filter(s -> s.length() == 13).filter(s -> s.startsWith("S")).forEach(System.out::println);
    }
}

● Stream< T> limt(long maxSize)：返回此流中的元素组成的流，截取前指定参数个数的数据
● Stream< T> skip(long n)：跳过指定参数个数的数据，返回由该流的剩余元素组成的流

public class OperateStream2 {
    public static void main(String[] args) {
        ArrayList<String> list= new ArrayList<>();
        list.add("Rarity");
        list.add("TwilightSparkle");
        list.add("RainbowDash");
        list.add("PinkiePie");
        list.add("AppleJack");
        list.add("FlutterShy");
        list.add("SunsetShimmer");
        list.add("StarlightGlimmer");
        list.add("Spike");

        //需求1：取前3个数据在控制台输出
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("--------");
        //需求2：跳过3个元素，把剩下的元素在控制台输出
        list.stream().skip(3).forEach(s -> System.out.println(s));
        System.out.println("--------");
        //需求3：跳过2个元素，把剩下的元素中前2个在控制台输出
        list.stream().skip(2).limit(2).forEach(s -> System.out.println(s));
    }
}

● static < T> Stream< T> concat(Stream a, Stream b)：合并a和b两个流为一个流
● Stream< T> distinct()：返回由该流的不同元素（根据Object.equals(Object)）组成的流

        //需求3：合并需求1和需求2得到的流，并把结果在控制台输出
//        Stream.concat(stream1,stream2).forEach(System.out::println);
        System.out.println("--------");
        //需求4：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复
        Stream.concat(stream1,stream2).distinct().forEach(s -> System.out.println(s));

● Stream< T> sorted()：返回由此流的元素组成的流，根据自然顺序排序
● Stream< T> sorted(Comparator comparator)：返回由该流的元素组成的流，根据提供的Comparator进行排序

public class OperateStream4 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Rarity");
        list.add("TwilightSparkle");
        list.add("RainbowDash");
        list.add("PinkiePie");
        list.add("AppleJack");
        list.add("FlutterShy");
        list.add("SunsetShimmer");
        list.add("StarlightGlimmer");
        list.add("Spike");

        list.stream().sorted().forEach(System.out::println);
        System.out.println("--------");
        
        list.stream().sorted((s1, s2) -> {
            int num = s1.length() - s2.length();
            int num1 = num == 0 ? s1.compareTo(s2) : num;
            return num1;
        }).forEach(System.out::println);
    }
}

● < R> Stream< R> map(Function mapper)：返回由给定函数应用于此流的元素的结果组成的流
            Function接口中的方法        R apply(T t)
● IntStream mapToInt(ToIntFunction mapper)：返回一个IntStream其中包含将给定函数应用于此流的元素的结果
            IntStream：表示原始int流
            ToIntFunction接口中的方法        int applyAsInt(T value)

public class OperateStream5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        list.add("50");

        //需求：将集合中的字符串数据转换为整数之后在控制台输出
        list.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println);
        System.out.println("--------");
        list.stream().map(Integer::parseInt).forEach(System.out::println);
        System.out.println("--------");
        list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);

        //int sum() 是IntStream中特有的方法
        int sum = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(sum);
    }
}

1.4 Stream流的常见终结操作方法

Stream流的常见终结操作方法
● void forEach(Consumer action)：对此流的每个元素执行操作
Consumer接口中的方法 void accept(T t)：对给定的参数执行此操作
● long count()：返回此流中的元素数

        //需求1：把集合中的元素在控制台输出
        list.stream().forEach(s-> System.out.println(s));
        //需求2：统计集合中有几个以R开头的元素，并把统计结果在控制台输出
        long count = list.stream().filter(s -> s.startsWith("R")).count();
        System.out.println(count);

1.5 Stream流的练习

现在有两个ArrayList集合，分别存储6名男演员名称和6名女演员名称，要求完成如下操作
● 男演员只要名字为3个字的前三人
● 女演员只要姓林的，并且不要第一个
● 把过滤后的男演员姓名和女演员姓名合并到一起
● 把上一步操作后的元素作为构造方法的参数创建演员对象啊，遍历数据
演员类Actor已经提供，里面有一个成员变量，一个带参构造方法，以及成员变量对应的get/set方法

public class StreamPractice {
    public static void main(String[] args) {
        ArrayList<String> manList = new ArrayList<String>();
        manList.add("刘德华");
        manList.add("吴彦祖");
        manList.add("成龙");
        manList.add("吴京");
        manList.add("李连杰");
        manList.add("周星驰");

        ArrayList<String> womenList = new ArrayList<String>();
        womenList.add("林志玲");
        womenList.add("奥黛丽·赫本");
        womenList.add("林青霞");
        womenList.add("王祖贤");
        womenList.add("张柏芝");
        womenList.add("林心如");

/*        //男演员只要名字为3个字的前三人
        Stream<String> menStream = manList.stream().filter(s -> s.length() == 3).limit(3);

        //女演员只要姓林的，并且不要第一个
        Stream<String> womenStream = womenList.stream().filter(s -> s.startsWith("林")).skip(1);

        //把过滤后的男演员姓名和女演员姓名合并到一起
        Stream<String> actorStream = Stream.concat(menStream, womenStream);

        //把上一步操作后的元素作为构造方法的参数创建演员对象啊，遍历数据
        actorStream.map(Actor::new).forEach(p -> System.out.println(p.getName()));*/

        Stream.concat(manList.stream().filter(s -> s.length() == 3).limit(3), womenList.stream().filter(s -> s.startsWith("林")).skip(1)).map(Actor::new).forEach(s->System.out.println(s.getName()));

    }
}

1.6 Stream流的收集操作

对数据使用Stream流的方式操作完毕后，我想把流中的数据收集到集合中，该怎么办呢？

Stream流的收集方法
● R collect(Collector collector)
● 但是这个收集方法的参数是一个Collector接口

工具类Collectors提供了具体的收集方式
● public static <T> Collector toList()：把元素收集到List集合中
● public static <T> Collector toSet()：把元素收集到Set集合中
● public static Colletor toMap(Function keyMapper,Function valueMapper：把元素收集到Map集合中

RainyRarity

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
25.Stream流（基础班完结）

1.Stream流1.1 体验Stream流需求：按照下面的要求完成集合的创建和遍历① 创建一个集合，存储多个字符串元素② 把集合中所有以“R”开头的元素存储到一个新的集合③ 把“R”开头的集合中的长度为6的元素存储到一个新的集合④ 遍历上一步得到的集合使用Stream流的方式完成过滤操作    array.stream().filter(s -> s.startsWith("R")).filter(s -> s.length() == 6
复制链接

扫一扫