Stream流式编程

最新推荐文章于 2023-12-11 10:05:33 发布
最新推荐文章于 2023-12-11 10:05:33 发布
阅读量365 收藏 1
点赞数
分类专栏： Java基础知识 文章标签： java 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46567616/article/details/125095076
版权

Stream流管道

1、Stream定义

​ Stream表示数据流，它没有数据结构，本身也不存储元素，其操作也不会改变源Stream，而是生成新Stream.作为一种操作数据的接口，它提供了过滤、排序、映射、聚合等多种操作方法。

2、Stream有什么用？

Stream当成一个装饰后的Iterator。原始版本的Iterator，用户只能逐个遍历元素并对其执行某些操作；包装后的Stream，用户只要给出需要对其包含的元素执行什么操作，比如“过滤掉长度大于10的字符串”、“获取每个字符串的首字母”等，具体这些操作如何应用到每个元素上，就给Stream就好了！原先是人告诉计算机一步一步怎么做，现在是告诉计算机做什么，计算机自己决定怎么做。

3、如何使用Stream？

Stream可以由数组或集合创建，对流的操作分为两种：

  1. 中间操作，每次返回一个新的流，可以有多个。

  2. 终端操作，每个流只能进行一次终端操作，终端操作结束后流无法再次使用。终端操作会产生一个新的集合或值。

Stream的使用过程有着固定的模式：

  1. 创建Stream

  2. 通过中间操作，对原始Stream进行“变化”并生成新的Stream

  3. 使用终端操作，生成最终结果

4、Stream的特性

Stream有几个特性：

  1. stream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果。

  2. stream不会改变数据源，通常情况下会产生一个新的集合或一个值。

  3. stream具有延迟执行特性，只有调用终端操作时，中间操作才会执行。

5、一次性的流

流和迭代器类似，只能迭代一次。

Stream<String> stream = list.stream().map(Person::getName).sorted().limit(10);         
List<String> newList = stream.collect(Collectors.toList());
List<String> newList2 = stream.collect(Collectors.toList());
//上面代码中第三行会报错，因为第二行已经使用过这个流，这个流已经被消费掉了。

6、Stream的创建

数据源（source）也就是数据的来源，可以通过多种方式获得 Stream 数据源，下面列举几种常见的获取方式。

首先我们先创建一个 Person 泛型的 List

List<Person> list = new ArrayList<>();
list.add(new Person("jack", 20));
list.add(new Person("mike", 25));
list.add(new Person("tom", 30));

Person 类包含年龄和姓名两个成员变量

private String name;
private int age;

6.1、 stream() / parallelStream()

最常用到的方法，将集合转换为流

List list = new ArrayList();
// return Stream<E>
list.stream();

6.2、filter(T -> boolean)

保留 boolean 为 true 的元素

//保留年龄为 20 的 person 元素
list = list.stream()
            .filter(person -> person.getAge() == 20)
            .collect(Collectors.toList());

//打印输出 [Person{name='jack', age=20}]

collect(toList()) 可以把流转换为 List 类型，

6.3、distinct()

去除重复元素，这个方法是通过类的 equals 方法来判断两个元素是否相等的

如例子中的 Person 类，需要先定义好 equals 方法，不然类似[Person{name=‘jack’, age=20}, Person{name=‘jack’, age=20}] 这样的情况是不会处理的。

6.4、sorted() / sorted((T, T) -> int)

如果流中的元素的类实现了 Comparable 接口，即有自己的排序规则，那么可以直接调用 sorted() 方法对元素进行排序，如 Stream

反之, 需要调用 sorted((T, T) -> int) 实现 Comparator 接口

根据年龄大小来比较：

list = list.stream()
           .sorted(Comparator.comparingInt(Person::getAge))
           .collect(Collectors.toList());

6.5、数字排序

	/**
     * 数字排序
     */
    public static void testIntegerSort() {
        List<Integer> list = Arrays.asList(4, 2, 5, 3, 1);
        System.out.println(list);//执行结果：[4, 2, 5, 3, 1]
        //升序
        list.sort((a, b) -> a.compareTo(b.intValue()));
        System.out.println(list);//执行结果：[1, 2, 3, 4, 5]
        //降序
        list.sort((a, b) -> b.compareTo(a.intValue()));
        System.out.println(list);//执行结果：[5, 4, 3, 2, 1]
    }

6.6、字符串排序

	/**
     * 字符串排序
     */
    public static void testStringSort() {
        List<String> list = new ArrayList<>();
        list.add("aa");
        list.add("cc");
        list.add("bb");
        list.add("ee");
        list.add("dd");
        System.out.println(list);//执行结果：aa, cc, bb, ee, dd
        //升序
        list.sort((a, b) -> a.compareTo(b.toString()));
        System.out.println(list);//执行结果：[aa, bb, cc, dd, ee]
        //降序
        list.sort((a, b) -> b.compareTo(a.toString()));
        System.out.println(list);//执行结果：[ee, dd, cc, bb, aa]
    }

6.7、对象字段排序

	/**
     * 对象串排序
     */
    public void testObjectSort() {
        List<Person> list = new ArrayList<>();
        list.add(new Person("三炮", 48));
        list.add(new Person("老王", 35));
        list.add(new Person("小明", 8));
        list.add(new Person("叫兽", 70));
        System.out.println(list); //执行结果：[Person{name='三炮', age=48}, Person{name='老王', age=35}, Person{name='小明', age=8}, Person{name='叫兽', age=70}]
        //按年龄升序
        list.sort((a, b) -> Integer.compare(a.age, b.getAge()));
        System.out.println(list);//执行结果：[Person{name='小明', age=8}, Person{name='老王', age=35}, Person{name='三炮', age=48}, Person{name='叫兽', age=70}]
        //按年龄降序
        list.sort((a, b) -> Integer.compare(b.age, a.getAge()));
        System.out.println(list);//执行结果：[Person{name='叫兽', age=70}, Person{name='三炮', age=48}, Person{name='老王', age=35}, Person{name='小明', age=8}]
        //如果按姓名排序，其实就是按字符串排序一样
    }

6.8、limit(long n)

返回前 n 个元素

list = list.stream()
            .limit(2)
            .collect(Collectors.toList());
//打印输出 [Person{name='jack', age=20}, Person{name='mike', age=25}]

6.9、skip(long n)

去除前 n 个元素

list = list.stream()
            .skip(2)
            .collect(Collectors.toList());

//打印输出 [Person{name='tom', age=30}]

注意：skip(m)用在 limit(n) 前面时，先去除前 m 个元素再返回剩余元素的前 n 个元素

limit(n) 用在 skip(m) 前面时，先返回前 n 个元素再在剩余的 n 个元素中去除 m 个元素

7、map(T -> R) 将流中的每一个元素 T 映射为 R（类似类型转换）

List<String> newlist = list.stream().map(Person::getName).collect(Collectors.toList());

7.1、flatMap(T -> Stream)

将流中的每一个元素 T 映射为一个流，再把每一个流连接成为一个流。

List<String> list = new ArrayList<>();
list.add("aaa bbb ccc");
list.add("ddd eee fff");
list.add("ggg hhh iii");

list = list.stream().map(s -> s.split(" ")).flatMap(Arrays::stream).collect(toList());

上面例子中，我们的目的是把 List 中每个字符串元素以” “分割开，变成一个新的 List。
首先 map 方法分割每个字符串元素，但此时流的类型为 Stream。

7.2、anyMatch(T -> boolean)

流中是否有一个元素匹配给定的 T -> boolean 条件

是否存在一个 person 对象的 age 等于 20：

boolean b = list.stream().anyMatch(person -> person.getAge() == 20);

7.3、 allMatch(T -> boolean)

流中是否所有元素都匹配给定的 T -> boolean 条件

boolean result = list.stream().allMatch(Person::isStudent);

7.4、findAny() 和 findFirst()

findAny()：找到其中一个元素 （使用 stream() 时找到的是第一个元素；使用 parallelStream()并行时找到的是其中一个元素）
findFirst()：找到第一个元素
值得注意的是，这两个方法返回的是一个 Optional 对象，它是一个容器类，能代表一个值存在或不存在

7.5、count() 返回流中元素个数，结果为 long 类型。

7.6、collect() 收集方法，我们很常用的是 collect(toList())，当然还有 collect(toSet()) 等，参数是一个收集器接口

7.7、forEach()

//打印各个元素：
list.stream().forEach(System.out::println);


再比如说 MyBatis 里面访问数据库的 mapper 方法：
//向数据库插入新元素：
list.stream().forEach(PersonMapper::insertPerson);

数值流

  • mapToInt(T -> int) : return IntStream
  • mapToDouble(T -> double) : return DoubleStream
  • mapToLong(T -> long) : return LongStream
IntStream intStream = list.stream().mapToInt(Person::getAge);

函数汇总

1、counting

long l = list.stream().count();

2、summingInt ，summingLong ，summingDouble

summing，没错，也是计算总和，不过这里需要一个函数参数

计算 Person 年龄总和：

int sum = list.stream().mapToInt(Person::getAge).sum();

3、averagingInt，averagingLong，averagingDouble

求平均数

OptionalDouble average = list.stream().mapToInt(Person::getAge).average();

4、summarizingInt，summarizingLong，summarizingDouble

IntSummaryStatistics l = list.stream().collect(summarizingInt(Person::getAge));

IntSummaryStatistics 包含了计算出来的平均值，总数，总和，最值，可以通过下面这些方法获得相应的数据

5、取最值

maxBy，minBy 两个方法，需要一个 Comparator 接口作为参数

Optional<Person> optional = list.stream().collect(maxBy(comparing(Person::getAge)));
//
Optional<Person> optional = list.stream().max(comparing(Person::getAge));

6、joining 连接字符串

也是一个比较常用的方法，对流里面的字符串元素进行连接，其底层实现用的是专门用于字符串连接的 StringBuilder

String s = list.stream().map(Person::getName).collect(joining());

//结果：jackmiketom

String s = list.stream().map(Person::getName).collect(joining(","));

//结果：jack,mike,tom

//joining 还有一个比较特别的重载方法：即 Today 放开头，play games. 放结尾，and 在中间连接各个字符串
String s = list.stream().map(Person::getName).collect(joining(" and ", "Today ", " play games."));

//结果：Today jack and mike and tom play games.

7、groupingBy 分组

groupingBy 用于将数据分组，最终返回一个 Map 类型

Map<Integer, List<Person>> map = list.stream().collect(groupingBy(Person::getAge));
//例子中我们按照年龄 age 分组，每一个 Person 对象中年龄相同的归为一组。
Map<String,List<Person>> result = list.stream()
                                    .collect(Collectors.groupingby((person)->{
        if(person.getAge()>60)
            return "老年人";
        else if(person.getAge()>40)
            return "中年人";
        else
            return "青年人";
                                    }));
//另外可以看出，Person::getAge 决定 Map 的键（Integer 类型），list 类型决定 Map 的值（List 类型）

并行

我们通过 list.stream() 将 List 类型转换为流类型，我们还可以通过 list.parallelStream() 转换为并行流。

并行流就是把内容分成多个数据块，使用不同的线程分别处理每个数据块的流。这也是流的一大特点，要知道，在 Java 7 之前，并行处理数据集合是非常麻烦的，你得自己去将数据分割开，自己去分配线程，必要时还要确保同步避免竞争。

Stream 让程序员能够比较轻易地实现对数据集合的并行处理，但要注意的是，不是所有情况的适合，有些时候并行甚至比顺序进行效率更低，而有时候因为线程安全问题，还可能导致数据的处理错误，因此并行的性能问题非常值得我们思考。

比方说下面这个例子

 int i = Stream.iterate(1, a -> a + 1).limit(100).parallel().reduce(0, Integer::sum);

我们通过这样一行代码来计算 1 到 100 的所有数的和，我们使用了 parallel 来实现并行。

但实际上是，这样的计算，效率是非常低的，比不使用并行还低！一方面是因为装箱问题，这个前面也提到过，就不再赘述，还有一方面就是 iterate 方法很难把这些数分成多个独立块来并行执行，因此无形之中降低了效率。

流的可分解性
这就说到流的可分解性问题了，使用并行的时候，我们要注意流背后的数据结构是否易于分解。比如众所周知的 ArrayList 和 LinkedList，明显前者在分解方面占优。

我们来看看一些数据源的可分解性情况

数据源可分解性
ArrayList极佳
LinkedList差
IntStream.range极佳
Stream.iterate差
HashSet好
TreeSet好

顺序性

除了可分解性，和刚刚提到的装箱问题，还有一点值得注意的是一些操作本身在并行流上的性能就比顺序流要差，比如：limit，findFirst，因为这两个方法会考虑元素的顺序性，而并行本身就是违背顺序性的，也是因为如此 findAny 一般比 findFirst 的效率要高。
如众所周知的 ArrayList 和 LinkedList，明显前者在分解方面占优。

我们来看看一些数据源的可分解性情况

数据源可分解性
ArrayList极佳
LinkedList差
IntStream.range极佳
Stream.iterate差
HashSet好
TreeSet好

顺序性

除了可分解性，和刚刚提到的装箱问题，还有一点值得注意的是一些操作本身在并行流上的性能就比顺序流要差，比如：limit，findFirst，因为这两个方法会考虑元素的顺序性，而并行本身就是违背顺序性的，也是因为如此 findAny 一般比 findFirst 的效率要高。

夜雨星光~
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux网络编程socket框架总结
09-24
常用的Socket类型有两种：流式Socket （SOCK_STREAM）和数据报式Socket（SOCK_DGRAM）。流式是一种面向连接的Socket，针对于面向连接的TCP服务应用；数据 报式Socket是一种无连接的Socket，对应于无连接的UDP服务...
C++网络编程
09-09
sockets（套接字）编程有三种，流式套接字（SOCK_STREAM），数据报套接字 （SOCK_DGRAM），原始套接字（SOCK_RAW）；基于TCP的socket编程是采用的流式套接字(SOCK_STREAM)。基于UDP采 用的数据报套接字(SOCK_DGRAM).
Stream filter()过滤有效数据
热门推荐
持之以恒！
09-18 8万+
filter()是一个中间操作，可以与 reduce()、collect()、map() 等一起使用。filter一般适用于list集合,主要作用就是模拟sql查询，从集合中查询想要的数据。 java官方文档语法如下。 filter(Predicate predicate) 它返回Stream的实例，该实例在处理Predicate后包含过滤后的数据。它被用作中间操作。filter()可用于许多不同的场景。如果我们想根据任何条件筛选list, array 或map，我们可以使用 lambda 表达式和
Stream流式编程详解
muranchenhui的博客
05-21 3956
Stream流式编程详解 一、 什么是 Stream Stream 中文称为 “流”，通过将集合转换为这么一种叫做 “流” 的元素序列，通过声明性方式，能够对集合中的每个元素进行一系列并行或串行的流水线操作。 换句话说，你只需要告诉流你的要求，流便会在背后自行根据要求对元素进行处理，而你只需要 “坐享其成”。 二、流操作 整个流操作就是一条流水线，将元素放在流水线上一个个地进行处理。 其中数据源便是原始集合，然后将如 List 的集合转换为 Stream 类型的流，并对流进行一系列的中间操作，比如过滤保留部
stream流式编程
weixin_46113450的博客
03-20 518
文章目录stream api 流式编程常用的stream三种创建方式Stream的终止操作Collectors 具体方法常用方法filtermapgroupBy求和交集,并集,差集flatMappeekdistinctlimitsortedmatch匹配find寻找元素计数和极值 stream api 流式编程 常用的stream三种创建方式 集合 Collection.stream() 静态方法 Stream of 数组 Arrays.stream //1.集合 Stream<Stu
Java Stream流式编程
ThinkStu的博客
08-09 5万+
Java Stream 从 JDK8 开始引入，支持链式书写。
基础深化和提高-java函数式编程
11-11
Stream API 则提供了对集合数据进行流式操作的功能，包括过滤、映射、归约等。 函数式编程的特点包括： 高阶函数：函数作为一等公民，可以作为参数传递、返回值返回。在Java中，通过Lambda表达式，可以很方便地...
《Java 8 in Action》是一本关于 Java 编程语言的书籍，重点介绍了 Java 8 中引入的新特性和改进
最新发布
02-21
Stream API： 介绍 Java 8 中引入的 Stream API，以及如何使用 Stream API 来处理集合数据和进行流式操作。 新的日期和时间 API： 探讨 Java 8 中新增的日期和时间 API，以及如何使用这些 API 来处理日期、时间和...
Stream 流式编程
tszc95的博客
10-08 146
Java Stream是Java 8中引入的一种操作集合、数组等数据源的元素序列的抽象概念。它提供了一种函数式编程的方式来处理和操作数据，使得代码更加简洁、易读。Stream可以看作是一系列数据元素的流动，类似于水流在管道中流动的概念。在Stream中，可以进行各种中间操作和终止操作，来对数据进行处理和转换。元素序列：Stream将数据源中的元素组成一个序列，每个元素都是通过一系列操作逐个被处理的。惰性求值：Stream的操作通常是惰性求值的，即只有在执行终止操作时才会触发中间操作的执行。
总算给女盆友讲明白了，如何使用stream流的filter()操作
Candyz7的博客
12-05 1万+
在上一篇文章中《这么简单，还不会使用java8 stream流的map()方法吗？》分享了使用stream的map()方法，不知道小伙伴还有印象吗，先来回顾下要点，map()方法是把一个流中的元素T转换为另外一个新流中的元素R，转换完成后两个流的元素个数不发生改变，具体怎么使用，请小伙伴移步上篇查看。在上篇文章中遗留了一个问题，本篇文章来解决它。先来看stream的另一个API--filter()方法。先来看下filter方法的定义，该方法返回一个新流，这个新流中的元素要匹配给定的表达式。从方法的入参及出参
Java8 新特性 —— Stream 流式编程
低吟不作语的博客
11-14 3908
本文部分摘自 On Java 8 流概述 集合优化了对象的存储，大多数情况下，我们将对象存储在集合是为了处理他们。使用流可以帮助我们处理对象，无需迭代集合中的元素，即可直接提取和操作元素，并添加了很多便利的操作，例如查找、过滤、分组、排序等一系列操作。 流的一个核心好处是：它使得程序更加短小并且易于理解，当结合 Lambda 表达式和方法引用时，会让人感觉自成一体。总而言之，流就是一种高效且易于使用的处理数据的方式。 观察下面的例子： public class Randoms { ..
Java中Stream流式编程从入门到精通
qq_42757706的博客
10-20 165
1.Java8开始引入，支持链式书写； 2.存在惰性计算，短路操作，可消费性，所以性能上要优于传统编程； (1).惰性计算:流的元素只在需要时才进行计算，不会提前计算整个流; (2).短路操作:类似于 && ，|| 前面满足条件，后面的计算直接略过； (3).可消费性:流只能被消费一次，即每个元素只能被处理一次;
stream流中filter的使用
m0_46351037的博客
10-09 2万+
stream流中filter方法的使用
Java新特性：Stream流式编程
栗筝i的博客
07-10 1432
Stream 流是 Java8 提供的新功能，是对集合对象功能的增强，能对集合对象进行各种非常便利、高效的聚合操作，或大批量数据操作。Stream 流以一种声明性方式处理数据集合，它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用fork/join并行方式来拆分任务和加速处理过程。 Stream 流是从支持数据处理操作的源生成的元素序列，源可以是数组、文件、集合、函数。流不是集合元素，它不是数据结构并不保存数据，它的主要目的在于计算
探索Java 8新特性：流式编程（Stream流）
m0_50033700的博客
08-14 803
简要介绍Java 8中引入的流式编程特性，探讨流式编程的定义、基本操作、中间操作、终端操作以及实际应用案例。
万字详解 Stream 流式编程，写代码也可以很优雅
Java知音
12-11 132
戳上方蓝字“Java知音”关注我1引言流式编程的概念和作用Java 流(Stream)是一连串的元素序列，可以进行各种操作以实现数据的转换和处理。流式编程的概念基于函数式编程的思想，旨在简化代码，提高可读性和可维护性。Java Stream 的主要作用有以下几个方面：简化集合操作： 使用传统的 for 循环或迭代器来处理集合数据可能会导致冗长而复杂的代码。而使用流式编程，能够用更直观、更简洁的方式...
java stream流式编程
10-22
Java Stream流式编程是一种函数式编程风格的集合操作方法，它可以让我们以一种更简洁、更易读的方式对集合进行操作。Stream流分为两种类型：流(Stream)和并行流(ParallelStream)。流表示顺序流，按照数据源的顺序...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值