Stream流

forEach方法,用来遍历流中的数据

是一个终结方法,遍历之后就不能继续调用Stream流中的其他方法

java 复制代码
		//获取一个Stream流
        Stream<String> stream = Stream.of("张三", "李四", "王五", "赵六", "田七");
        //使用Stream流中的方法forEach对Stream流中的数据进行遍历
        stream.forEach(name -> System.out.println(name));

Stream流中的常用方法_filter:用于对Stream流中的数据进行过滤

Stream filter(Predicate<? super T> predicate);

filter方法的参数Predicate是一个函数式接口,所以可以传递Lambda表达式,对数据进行过滤

Predicate中的抽象方法:

boolean test(T t);

java 复制代码
		//创建一个Stream流
        Stream<String> stream = Stream.of("张三丰", "张翠山", "赵敏", "周芷若", "张无忌");
        //对Stream流中的元素进行过滤,只要姓张的人
        Stream<String> stream2 = stream.filter(name -> name.startsWith("张"));
        //遍历stream2流
        stream2.forEach(name -> System.out.println(name));

        /*
            Stream流属于管道流,只能被消费(使用)一次
            第一个Stream流调用完毕方法,数据就会流转到下一个Stream上
            而这时第一个Stream流已经使用完毕,就会关闭了
            所以第一个Stream流就不能再调用方法了
            IllegalStateException: stream has already been operated upon or closed
         */
        //遍历stream流
        stream.forEach(name -> System.out.println(name));

Stream流中的常用方法_map:用于类型转换

如果需要将流中的元素映射到另一个流中,可以使用map方法.

Stream map(Function<? super T, ? extends R> mapper);

该接口需要一个Function函数式接口参数,可以将当前流中的T类型数据转换为另一种R类型的流。

Function中的抽象方法:

R apply(T t);

java 复制代码
//获取一个String类型的Stream流
        Stream<String> stream = Stream.of("1", "2", "3", "4");
        //使用map方法,把字符串类型的整数,转换(映射)为Integer类型的整数
        stream.map(s -> Integer.parseInt(s)).forEach(i -> System.out.println(i));

Stream流中的常用方法_count:用于统计Stream流中元素的个数

long count();

count方法是一个终结方法,返回值是一个long类型的整数

所以不能再继续调用Stream流中的其他方法了

java 复制代码
		ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        //获取一个Stream流,统计元素个数
        long count = list.stream().count(); // count野心很大
        System.out.println(count);

Stream流的收集方法

R collect(Collector collector)

复制代码
它是通过工具类Collectors提供了具体的收集方式
    public static <T> Collector toList():把元素收集到List集合中
    public static <T> Collector toSet():把元素收集到Set集合中
    public static Collector toMap(Function keyMapper,Function valueMapper):把元素收集到Map集合中
java 复制代码
//创建List集合对象
     List<String> list = new ArrayList<String>();
     list.add("林青霞");
     list.add("张曼玉");
     list.add("王祖贤");
     list.add("柳岩");

     //需求1:得到名字为3个字的流
     Stream<String> listStream = list.stream().filter(s -> s.length() == 3);

     //需求2:把使用Stream流操作完毕的数据收集到List集合中并遍历
     List<String> names = listStream.collect(Collectors.toList());
     for (String name : names) {
         System.out.println(name);
     }

     //创建Set集合对象
     Set<Integer> set = new HashSet<Integer>();
     set.add(10);
     set.add(20);
     set.add(30);
     set.add(33);
     set.add(35);

     //需求3:得到年龄大于25的流
     Stream<Integer> setStream = set.stream().filter(age -> age > 25);

     //需求4:把使用Stream流操作完毕的数据收集到Set集合中并遍历
     Set<Integer> ages = setStream.collect(Collectors.toSet());
     for (Integer age : ages) {
         System.out.println(age);
     }

     //定义一个字符串数组,每一个字符串数据由姓名数据和年龄数据组合而成
     String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33", "柳岩,25"};

     //需求5:得到字符串中年龄数据大于28的流
     Stream<String> arrayStream = Stream.of(strArray).filter(
             s -> Integer.parseInt(s.split(",")[1]) > 28);

     //需求6:把使用Stream流操作完毕的数据收集到Map集合中并遍历,字符串中的姓名作键,年龄作值
     Map<String, Integer> map = arrayStream.collect(Collectors.toMap(
             s -> s.split(",")[0],
             s -> Integer.parseInt(s.split(",")[1])
     ));
     Set<String> keySet = map.keySet();
     for (String key : keySet) {
         System.out.println(key + ",," + map.get(key));
     }

Stream流中的常用方法_skip:用于跳过元素

如果希望跳过前几个元素,可以使用skip方法获取一个截取之后的新流:

Stream skip(long n);

如果流的当前长度大于n,则跳过前n个;否则将会得到一个长度为0的空流。

java 复制代码
//获取一个Stream流
        String[] arr = {"美羊羊","喜洋洋","懒洋洋","灰太狼","红太狼"};
        Stream<String> stream = Stream.of(arr);
        //使用skip方法跳过前3个元素
        stream.skip(3).forEach(name -> System.out.println(name));

Stream流中的常用方法_concat:用于把流组合到一起

如果有两个流,希望合并成为一个流,那么可以使用Stream接口的静态方法concat

static Stream concat(Stream<? extends T> a, Stream<? extends T> b)

java 复制代码
		//创建一个Stream流
        Stream<String> stream1 = Stream.of("张三丰", "张翠山", "赵敏", "周芷若", "张无忌");
        //获取一个Stream流
        String[] arr = {"美羊羊","喜洋洋","懒洋洋","灰太狼","红太狼"};
        Stream<String> stream2 = Stream.of(arr);
        //把以上两个流组合为一个流
        Stream.concat(stream1, stream2).forEach(name -> System.out.println(name));
相关推荐
xyliiiiiL4 分钟前
一文总结常见项目排查
java·服务器·数据库
shaoing6 分钟前
MySQL 错误 报错:Table ‘performance_schema.session_variables’ Doesn’t Exist
java·开发语言·数据库
腥臭腐朽的日子熠熠生辉1 小时前
解决maven失效问题(现象:maven中只有jdk的工具包,没有springboot的包)
java·spring boot·maven
ejinxian1 小时前
Spring AI Alibaba 快速开发生成式 Java AI 应用
java·人工智能·spring
杉之1 小时前
SpringBlade 数据库字段的自动填充
java·笔记·学习·spring·tomcat
weixin_420947641 小时前
windows golang,consul,grpc学习
windows·golang·consul
圈圈编码1 小时前
Spring Task 定时任务
java·前端·spring
俏布斯2 小时前
算法日常记录
java·算法·leetcode
27669582922 小时前
美团民宿 mtgsig 小程序 mtgsig1.2 分析
java·python·小程序·美团·mtgsig·mtgsig1.2·美团民宿
爱的叹息2 小时前
Java 连接 Redis 的驱动(Jedis、Lettuce、Redisson、Spring Data Redis)分类及对比
java·redis·spring