Java 8中 Stream小知识小技巧方法梳理

目录
  • 前言
  • 只能遍历的一次 Stream
    • 那么为什么流只能遍历一次呢?
  • 流操作
    • 中间操作
    • 终端操作

前言

上篇只是简单的动手操作操作了流(stream),那 stream 到底是什么呢?

官方的简短定义:从支持数据处理操作的源生成的元素序列

分成三部分:

  • 元素序列:你可以简单将它类比于一样,不过集合说的是数据的集合,而 stream 重点在于表达计算。如我们之前说到的 filter、map、sorted、limit等等
  • :昨天我提到,如果了解过 Liunx 管道命令的朋友们,会知道,Liunx 的管道命令中的前一条命令的结果(输出流)就是执行下一条命令的输入流。 stream流其实也是类似的,每次执行完一个 filter、sorted 等等它们的返回值也是 stream 流,然后作为下一个操作的输入流,这种。
  • 数据处理:这里说的处理,就是那些filter、map、sorted、limit等。

你可以把它理解为概念上或是形式上的数据结构,而不是具体的。

只能遍历的一次 Stream

Stream 流和 迭代器一样,它只能够迭代一次

当它遍历完的时候,我们就称它已经消费完了。如果还想重新执行操作,那么就只能从原来的地方再获取一个流啦。

 /**
      * 图个乐子
      */
 public static List<String> list = Arrays.asList("医医","一一","花花","菡菡","春春","宁姐","...");
 ​
 public static void main(String[] args) {
     Stream<String> stream = list.stream();
     stream.forEach(System.out::println);
     stream.forEach(System.out::println);
 }

当执行第二句stream.forEach(System.out::println);时,会爆出如下异常:

 Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
     at java.util.stream.AbstractPipeline.sourceStageSpliterator(AbstractPipeline.java:279)
     at java.util.stream.ReferencePipeline$Head.forEach(ReferencePipeline.java:580)
     at com.nzc.stream02.Stream02Demo.main(Stream02Demo.java:25)

stream has already been operated upon or closed :流已经被操作完或者关闭啦~

那么为什么流只能遍历一次呢?

我的回答肯定是 Java 中的设计是如此。

我们先来回忆一下我昨天没提到的一个知识点:

随便举一个例子,然后我们将 filter、map、limit、collect 都使用上。

 List<Student> students = new ArrayList<>();
 ​
 students.add(new Student("学生A", "大学1", 18, 98.0));
 students.add(new Student("学生A", "大学1", 18, 91.0));
 students.add(new Student("学生A", "大学1", 18, 90.0));
 students.add(new Student("学生A", "大学1", 18, 76.0));
 students.add(new Student("学生B", "大学1", 18, 91.0));
 students.add(new Student("学生C", "大学1", 19, 65.0));
 students.add(new Student("学生D", "大学2", 20, 80.0));
 students.add(new Student("学生E", "大学2", 21, 78.0));
 students.add(new Student("学生F", "大学2", 20, 67.0));
 students.add(new Student("学生G", "大学3", 22, 87.0));
 students.add(new Student("学生H", "大学3", 23, 79.0));
 students.add(new Student("学生I", "大学3", 19, 92.0));
 students.add(new Student("学生J", "大学4", 20, 84.0));
 List<String> collect = students.stream().filter(student -> student.getAge() > 20).map(student -> student.getName()).limit(3).collect(Collectors.toList());

昨天我没有具体说明这几步是如何执行的

画张图来简要的说明一下:

  • filter, 根据条件筛选掉一些元素
  • map,将元素转换成其他的形式
  • limit,将流进行截断,只获取其中的一部分
  • collect,这里主要就是将流转换成其他的集合对象,这一步也是流的终端操作,之后也会聊到。

在这里你可以看到Java 8中的 stream 的设计,就是只能遍历一次,并且当执行完终端操作的时候,流也是已经关闭或者说是消费完了。

流操作

上面刚刚提到了终端操作,这也是一个小小的知识点。

Stream 的api提供了不少方法,诸如 filter、sotred、limit、map、collect等。

其中 filter、sotred、limit、map 它们的返回结果仍然是一个stream 流,这些操作,我们称之为中间操作。并且它们之间的连接可以形成一个流水线任务

而 collect 则是一个终端操作,它会触发并执行流水线任务,最终关闭它

中间操作

就是上面说的 filter、map等等,但是需要注意的是,如果流水线上没有一个终端操作,那么你写的filter、map什么的,并不会执行任何处理。

通过一个简单的案例,来看一看stream流中的lambda的函数的执行流程。

     static List<Student> students = new ArrayList<>();
 ​
     static {
         students.add(new Student("学生A", "大学1", 18, 98.0));
         students.add(new Student("学生A", "大学1", 18, 91.0));
         students.add(new Student("学生A", "大学1", 18, 90.0));
         students.add(new Student("学生A", "大学1", 18, 76.0));
         students.add(new Student("学生B", "大学1", 18, 91.0));
         students.add(new Student("学生C", "大学1", 19, 65.0));
         students.add(new Student("学生D", "大学2", 20, 80.0));
         students.add(new Student("学生E", "大学2", 21, 78.0));
         students.add(new Student("学生F", "大学2", 20, 67.0));
         students.add(new Student("学生G", "大学3", 22, 87.0));
         students.add(new Student("学生H", "大学3", 23, 79.0));
         students.add(new Student("学生I", "大学3", 19, 92.0));
         students.add(new Student("学生J", "大学4", 20, 84.0));
     }
 public static void main(String[] args) {
     List<String> collect = students.stream().filter(student -> {
         System.out.println("filter==>" + student.getName() + ":" + student.getAge());
         return student.getAge() > 20;
     }).map(student -> {
         System.out.println("map==>" + student.getName() + ":" + student.getAge());
         return student.getName();
     }).collect(Collectors.toList());
 ​
 }

输出:

filter==>学生A:18
 map==>学生A:18
 filter==>学生A:18
 map==>学生A:18
 filter==>学生A:18
 map==>学生A:18
 filter==>学生A:18
 map==>学生A:18
 filter==>学生B:18
 map==>学生B:18
 filter==>学生C:19
 map==>学生C:19
 filter==>学生D:20
 filter==>学生E:21
 filter==>学生F:20
 filter==>学生G:22
 filter==>学生H:23
 filter==>学生I:19
 map==>学生I:19
 filter==>学生J:20

也许到这里还看的不明显,我们再加上一个 limit(3),来看一下这次会如何输出

 List<String> collect = students.stream().filter(student -> {
     System.out.println("filter==>" + student.getName() + ":" + student.getAge());
     return student.getAge() < 20;
 }).map(student -> {
     System.out.println("map==>" + student.getName() + ":" + student.getAge());
     return student.getName();
 }).limit(3).collect(Collectors.toList());
 ​
 System.out.println(collect);

输出结果:

 filter==>学生A:18
 map==>学生A:18
 filter==>学生A:18
 map==>学生A:18
 filter==>学生A:18
 map==>学生A:18
 [学生A, 学生A, 学生A]

1、实际上这里利用到的 limit(n) 就是俗称的短路技巧,像我们刚学 &&、| | 语法时一样,如果&&条件为false,则会短路,不执行&& 之后的表达式,这里的 limit 你可以看作是 || 的表达

Stream 流在内部迭代中主动帮我们进行了优化。

2、另外看似 filter 和 map 是两个独立的函数,但实际上他们都是在一次遍历中所进行的。这一点从输出中也可看出。

终端操作

终端操作,就是触发并执行流水线任务,最终关闭流的操作

像之前写的collect(Collectors.toList()) 和 forEach(System.out::println) 都是终端操作。

终端操作其结果返回的都是流的值,collect返回各种各样的集合啦,

forEach 返回的就是 void 值。

中间操作:

操 作 类型 结果 操作参数  
filter 中间 Stream Predicate T -> boolean
map 中间 Stream Stream Function T -> R
limit 中间 Stream    
sorted 中间 Stream Comparator (T, T) -> int
distinct 中间 Stream    

终端操作:

操 作 类 型 目 的
forEach 终端 消费流中的每个元素并对其应用 Lambda。这一操作返回 void
count 终端 返回流中元素的个数。这一操作返回 long
collect 终端 把流归约成一个集合,比如 List、Map 甚至是 Integer。

到此这篇关于Java 8中 Stream小知识小技巧方法梳理的文章就介绍到这了,更多相关Java 8 Stream 内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java 中如何使用 stream 流

    目录 前言 一.筛选和切片 1.1.筛选 filter 1.2.去重 distinct 1.3.切片 limit 1.4.跳过元素 skip 1.5.排序 sorted 1.6.小结与综合应用 二.映射 map 三.查找和匹配 3.1.匹配 anyMatch.allMatch和noneMatch 方法 3.2.查找 findAny 与 findFirst 3.3.小结 四.归约 4.1.元素求和 reduce 后记 前言 如果你了解过 Liunx ,了解过 Liunx 的中管道命令 | ,那么你

  • java使用stream判断两个list元素的属性并输出方式

    目录 使用stream判断两个list元素的属性并输出 stream判断列表是否包含某几个元素/重复元素 代码SHOW Java stream判断列表是否包含重复元素 使用stream判断两个list元素的属性并输出 /** * 使用stream判断两个list中元素不同的item */ @Test public void test1(){ List<Param> stringList1 = new LinkedList<Param>(){{ add(new Param(1,&qu

  • Java8 Stream流多字段求和、汇聚的实例

    目录 Stream流多字段求和.汇聚 实现方法 对象类型数据处理 Map类型数据处理 Stream分组求和使用笔记 分组求和使用 Stream流多字段求和.汇聚 实现方法 利用 Collectors.toMap(Function keyMapper, Function valueMapper, BinaryOperator mergeFunction) keyMapper:代表你最终想要获得的Map<Key, Value> 的Key valueMapper:代表你最终想要获得的Map<K

  • java Stream流常见操作方法(反射,类加载器,类加载,反射)

    目录 Stream流常见的中间操作方法 Stream流中常见的终结操作方法 反射 类加载器 反射概述 Stream流常见的中间操作方法 Streamfilter(Predicate predicate):用于对流中的数据进行过滤 predicate接口中的方法 boolean test(T t):对给定的参数进行判断,返回一个布尔值 Stream limit(long maxSize):返回此流中元素组成的流,截取前指定参数个数的数据 Stream skip(long n) :跳过指定参数个数据

  • Java基础之Stream流原理与用法详解

    目录 一.接口设计 二.创建操作 三.中间操作 四.最终操作 五.Collect收集 Stream简化元素计算 一.接口设计 从Java1.8开始提出了Stream流的概念,侧重对于源数据计算能力的封装,并且支持序列与并行两种操作方式:依旧先看核心接口的设计: BaseStream:基础接口,声明了流管理的核心方法: Stream:核心接口,声明了流操作的核心方法,其他接口为指定类型的适配: 基础案例:通过指定元素的值,返回一个序列流,元素的内容是字符串,并转换为Long类型,最终计算求和结果并

  • Java中DataInputStream和DataOutputStream的使用方法

    目录 简介 DataOutputStream DataInputStream 栗子1:写入数据 栗子2:读取 栗子3:保存学生信息 简介 在 io 包中,提供了两个与平台无关的数据操作流:数据输出流(DataOutputStream).数据输入流 (DataInputStream). 通常数据输出流会按照一定的格式将数据输出,再通过数据输入流按照一定的格式将数据读入.DataOutputStream 和 DataOutputStream 用来读写固定字节格式数据. DataOutputStrea

  • Java中ByteArrayInputStream和ByteArrayOutputStream用法详解

    目录 ByteArrayInputStream ByteArrayOutputStream ByteArrayInputStream 介绍ByteArrayInputStream 是字节数组输入流.它继承于 InputStream. InputStream 通过read()向外提供接口,供它们来读取字节数据:而 ByteArrayInputStream 的内部额外的定义了一个计数器,它被用来跟踪 read() 方法要读取的下一个字节. 它包含一个内部缓冲区,该缓冲区包含从流中读取的字节.也就是说

  • Java8中Stream的详细使用方法大全

    目录 一.概述 1.使用流的好处 2.流是什么? 二.分类 三.Stream的创建 1.通过 java.util.Collection.stream() 方法用集合创建流 2.使用 java.util.Arrays.stream(T[]array)方法用数组创建流 3.使用 Stream的静态方法:of().iterate().generate() 四.Stream API简介 1.遍历/匹配(foreach/find/match) 2.按条件匹配filter 3.聚合max.min.count

  • 一文详解Java中的Stream的汇总和分组操作

    目录 前言 一.查找流中的最大值和最小值 二.汇总 三.连接字符串 四.分组 1.分组 2.多级分组 3.按子组数据进行划分 后记 前言 在前面的文章中其实大家也已经看到我使用过collect(Collectors.toList()) 将数据最后汇总成一个 List 集合. 但其实还可以转换成Integer.Map.Set 集合等. 一.查找流中的最大值和最小值 static List<Student> students = new ArrayList<>(); ​ static

  • Java 8中 Stream小知识小技巧方法梳理

    目录 前言 只能遍历的一次 Stream 那么为什么流只能遍历一次呢? 流操作 中间操作 终端操作 前言 上篇只是简单的动手操作操作了流(stream),那 stream 到底是什么呢? 官方的简短定义:“从支持数据处理操作的源生成的元素序列” 分成三部分: 元素序列:你可以简单将它类比于一样,不过集合说的是数据的集合,而 stream 重点在于表达计算.如我们之前说到的 filter.map.sorted.limit等等 源:昨天我提到,如果了解过 Liunx 管道命令的朋友们,会知道,Liu

  • 四十九个javascript小知识实用技巧

    目录 一.js整数的操作 二.重写原生alert,记录弹框次数 三.数字交换不声明中间变量的方法 四.万物皆对象 五.If语句的变形 六.使用===,而不是== 七.使用闭包实现私有变量 八.创建对象的构造函数 九.小心使用typeof.instanceof和constructor 十.创建一个自调用函数(Self-calling Funtion) 十一.从数组中获取一个随机项 十二.在特定范围内获取一个随机数 十三.在0和设定的最大值之间生成一个数字数组 十四.生成一个随机的数字字母字符串 十

  • 在java List中进行模糊查询的实现方法

    比如我有下面这样一个List,里面存放的是多个Employee对象.然后我想对这个List进行按照Employee对象的名字进行模糊查询.有什么好的解决方案么? 比如我输入的查询条件为"wang",那么应该返回只包含employee1的List列表. List list = new ArrayList(); Employee employee1 = new Employee(); employee1.setName("wangqiang"); employee1.s

  • Java 8中日期和时间的处理方法

    Java 8新增了LocalDate和LocalTime接口,为什么要搞一套全新的处理日期和时间的API?因为旧的java.util.Date实在是太难用了. java.util.Date月份从0开始,一月是0,十二月是11,变态吧!java.time.LocalDate月份和星期都改成了enum,就不可能再用错了. java.util.Date和SimpleDateFormatter都不是线程安全的,而LocalDate和LocalTime和最基本的String一样,是不变类型,不但线程安全,

  • 详解在Java程序中运用Redis缓存对象的方法

    这段时间一直有人问如何在Redis中缓存Java中的List 集合数据,其实很简单,常用的方式有两种: 1. 利用序列化,把对象序列化成二进制格式,Redis 提供了 相关API方法存储二进制,取数据时再反序列化回来,转换成对象. 2. 利用 Json与java对象之间可以相互转换的方式进行存值和取值. 正面针对这两种方法,特意写了一个工具类,来实现数据的存取功能. 1. 首页在Spring框架中配置 JedisPool 连接池对象,此对象可以创建 Redis的连接 Jedis对象.当然,必须导

  • Java程序中实现调用Python脚本的方法详解

    本文实例讲述了Java程序中实现调用Python脚本的方法.分享给大家供大家参考,具体如下: 在程序开发中,有时候需要Java程序中调用相关Python脚本,以下内容记录了先关步骤和可能出现问题的解决办法. 1.在Eclipse中新建Maven工程: 2.pom.xml文件中添加如下依赖包之后update maven工程: <dependency> <groupId>org.python</groupId> <artifactId>jython</ar

  • Java链表中添加元素的原理与实现方法详解

    本文实例讲述了Java链表中添加元素的原理与实现方法.分享给大家供大家参考,具体如下: 1.链表中头节点的引入 1.1基本的链表结构: 1.2对于链表来说,若想访问链表中每个节点则需要把链表的头存起来,假如链表的头节点为head,指向链表中第一个节点,如图: 1.3使用代码表示此时的链表 //定义头节点 private Node head; //节点个数 private int size; //无参数构造函数 public LinkedList() { head = null; size = 0

  • 通过实例了解Java 8创建Stream流的5种方法

    这篇文章主要介绍了通过实例了解Java 8创建Stream流的5种方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 不知不觉间,Java已经发展到13了,来不及感慨时间过得真的太快了,来不及学习日新月异的技术更新,目前大多数公司还是使用的JDK8版本,一方面是版本的稳定,另一方面是熟悉,所以很多公司都觉得不升级也挺好. 说到JDK8,真的是一个里程碑的版本,一出世就受到所有开发者的青睐,并主动花时间和精力去学习,也是我见过企业升级JDK最豪爽

  • Java工作中常见的并发问题处理方法总结

    问题复现 1. "设备Aの奇怪分身" 时间回到很久很久以前的一个深夜,那时我开发的多媒体广告播放控制系统刚刚投产上线,公司开出的第一家线下生鲜店里,几十个大大小小的多媒体硬件设备正常联网后,正由我一台一台的注册及接入到已经上线的多媒体广告播控系统中. 注册过程简述如下: 每一个设备注册到系统中后,相应的在数据库设备表中都会新增一条记录,来存储这个设备的各项信息. 本来一切都有条不紊的进行着,直到设备A的注册打破了这默契的宁静-- 设备A注册完成后,我突然发现,数据库设备表中,新增了两条

  • 详解Java泛型中类型擦除问题的解决方法

    以前就了解过Java泛型的实现是不完整的,最近在做一些代码重构的时候遇到一些Java泛型类型擦除的问题,简单的来说,Java泛型中所指定的类型在编译时会将其去除,因此List 和 List 在编译成字节码的时候实际上是一样的.因此java泛型只能做到编译期检查的功能,运行期间就不能保证类型安全.我最近遇到的一个问题如下: 假设有两个bean类 /** Test. */ @Data @NoArgsConstructor @AllArgsConstructor public static class

随机推荐