Java数据处理利器-Stream流编程入门

最新推荐文章于 2024-05-03 22:04:55 发布
最新推荐文章于 2024-05-03 22:04:55 发布
阅读量740 收藏 2
点赞数 1
分类专栏： # Java技术 文章标签： java 大数据 stream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41170102/article/details/105654847
版权
本文详细介绍Java 8 Stream API的使用方法，包括流的概念、流的创建、中间操作如filter、map、flatMap等，以及终端操作如collect、reduce、match等。并通过实例演示如何利用Stream API处理集合数据，实现数据过滤、转换、聚合等功能。
摘要由CSDN通过智能技术生成

文章目录

什么是流

Java 8 API添加了一个新的抽象称为流Stream，其可以以一种声明式的方式处理数据。它将基础操作链接起来，能完成复杂的数据处理流水线，并提供了透明的并行处理机制。

Stream流的组成

  • 数据源
  • 中间操作
  • 终端操作

一图胜千言，从整体上了解下相关的内容

在这里插入图片描述
流与集合的区别：

  • 流相对于是时间上的集合，得到的是某一时刻的数据（面向计算）
  • 集合相对于是空间上的集合，需要真实的存储（面向存储）
  • 流只能遍历一次，集合可以反复操作
  • 流是内部迭代，集合是外部迭代

怎么使用流编程

下面将对流编程的操作和构建一一进行演示

创建一个实体类User方便我们使用

	class User {
        private Integer userId;
        private String userName;
        private String password;

        public User(Integer userId, String userName, String password) {
            this.userId = userId;
            this.userName = userName;
            this.password = password;
        }

        public Integer getUserId() {
            return userId;
        }

        public String getUserName() {
            return userName;
        }

        public String getPassword() {
            return password;
        }
    }

创建一个集合，作为我们数据操作的数据

		List<User> list = new ArrayList<User>() {
            {
                add(new User(5,"ckhhh", "123123"));
                add(new User(1,"zhangsan", "1232312"));
                add(new User(3,"lisi", "000000"));
                add(new User(2,"lisi", "4324324"));
                add(new User(4,"wangwu", "99999"));


            }
        };

中间操作

  1. 无状态的
  • filter使用
		/**
         * filter使用 按照指定条件过滤集合
         */
		  list.stream().
		             filter(user -> user.getUserName().equals("lisi")).
		             forEach(user ->
		                     System.out.println(JSON.toJSONString(user, true)));

打印用户名为lisi的用户的信息，结果如下：

{
	"password":"000000",
	"userId":3,
	"userName":"lisi"
}
{
	"password":"4324324",
	"userId":2,
	"userName":"lisi"
}
  • map使用
		/**
         * map使用 从一种类型转化为另一种类型的集合，user->string
         */
        list.stream().
                map(user -> user.getUserName()).
                forEach(user ->
                        System.out.println(JSON.toJSONString(user, true)));

使用map将集合分割，只获取所有用户并打印，结果如下：

"ckhhh"
"zhangsan"
"lisi"
"lisi"
"wangwu"
  • flatMap操作
   		/**
         * flatMap操作 接收一个元素，返回一个新的流(将对象转换为流操作）
         */
        list.stream()
                .flatMap(user -> Arrays.stream(user.getUserName().split("")))
                .forEach(user ->
                        System.out.println(JSON.toJSONString(user, true)));

使用flatMap将集合变为新的流：将名字分割成字符，然后打印，结果如下：

"c"
"k"
"h"
"h"
"h"
"z"
"h"
"a"
"n"
"g"
"s"
"a"
"n"
"l"
"i"
"s"
"i"
"l"
"i"
"s"
"i"
"w"
"a"
"n"
"g"
"w"
"u"
  • peek操作
		 /**
         * peek 中间操作 无状态的 操作完后流还可以使用  foreach使用后就不能用了
         * peek和foreach交替打印
         */
        list.stream()
                .peek(user -> System.out.println(user.getUserName()))
                .forEach(user ->
                        System.out.println(JSON.toJSONString(user, true)));

打印用户名，因为是无状态的，所以会执行完一下peek后执行一下foreach中的打印，结果如下

ckhhh
{
	"password":"123123",
	"userId":5,
	"userName":"ckhhh"
}
zhangsan
{
	"password":"1232312",
	"userId":1,
	"userName":"zhangsan"
}
lisi
{
	"password":"000000",
	"userId":3,
	"userName":"lisi"
}
lisi
{
	"password":"4324324",
	"userId":2,
	"userName":"lisi"
}
wangwu
{
	"password":"99999",
	"userId":4,
	"userName":"wangwu"
}
  1. 有状态的
  • sort操作
 		/**
         * sort操作，对数据按照规则排序
         * sorted是有状态的  所以会等peek结束之后再操作
         * peek和foreach就不会再交替打印了
         */
        list.stream()
                .peek(user -> System.out.println(user.getUserName()))
                .sorted(Comparator.comparing(User::getUserId))
                .forEach(user ->
                        System.out.println(JSON.toJSONString(user, true)));

排序后打印，是有状态的，所以必须所有peek执行完了后才能执行，根据userId升序排列，结果如下：

ckhhh
zhangsan
lisi
lisi
wangwu
{
	"password":"1232312",
	"userId":1,
	"userName":"zhangsan"
}
{
	"password":"4324324",
	"userId":2,
	"userName":"lisi"
}
{
	"password":"000000",
	"userId":3,
	"userName":"lisi"
}
{
	"password":"99999",
	"userId":4,
	"userName":"wangwu"
}
{
	"password":"123123",
	"userId":5,
	"userName":"ckhhh"
}
  • distinct操作
/**
         * distinct操作  去除重复
         */
        list.stream()
                .map(user -> user.getUserName())
                .distinct()
                .forEach(user ->
                        System.out.println(JSON.toJSONString(user, true)));

去除用户名中的重复项后打印用户名，结果如下：

"ckhhh"
"zhangsan"
"lisi"
"wangwu"
  • skip操作
		/**
         *  skip过滤掉前三条
         */
        list.stream()
                .sorted(Comparator.comparing(user ->user.getUserId()))
                .skip(3)
                .forEach(user ->
                        System.out.println(JSON.toJSONString(user, true)));

按id升序排序后，跳过前三条，从第四条开始打印，结果如下：

{
	"password":"99999",
	"userId":4,
	"userName":"wangwu"
}
{
	"password":"123123",
	"userId":5,
	"userName":"ckhhh"
}
  • limit操作
		 /**
         * limit操作  获取前三条
         */
        list.stream()
                .sorted(Comparator.comparing(user ->user.getUserId()))
                .limit(3)
                .forEach(user ->
                        System.out.println(JSON.toJSONString(user, true)));

按id升序排列后，打印前三条，结果如下：

{
	"password":"1232312",
	"userId":1,
	"userName":"zhangsan"
}
{
	"password":"4324324",
	"userId":2,
	"userName":"lisi"
}
{
	"password":"000000",
	"userId":3,
	"userName":"lisi"
}

终端操作

  1. 短路的操作
  • allMatch操作
		/**
         * allMatch 使用:是否全部满足终端操作，短路的操作
         * 如果发现了不匹配的  就不会继续执行了，peek中打印的数据打不符合的就停止了
         */
        boolean b = list.stream()
                .peek(user -> System.out.println(user.getUserId()))
                .allMatch(user->user.getUserId()> 2);
        System.out.println(b);

判断是否所有的用户id都大于2，一旦发现小于等于2的就返回false，结果如下

5
1
false
  • anyMatch操作
		/**
         * anyMatch使用  ：只要有满足的，就返回true
         * 短路的  找到一个符合的就返回true
         */
        boolean c = list.stream()
                 .peek(user -> System.out.println(user.getUserId()))
                .anyMatch(user->user.getUserId()> 2);
        System.out.println(c);

判断是否有用户id大于2，一旦发现大于2的就返回true，结果如下

5
true
  • noneMatch操作
		/**
         * noneMatch使用：所有的都没匹配上 返回true
         * 短路的，找到一个符合的就返回false
         */
        boolean d = list.stream()
                 .peek(user -> System.out.println(user.getUserId()))
                .noneMatch(user->user.getUserId()> 2);
        System.out.println(d);

判断是否没有用户id大于2，一旦发现大于2的就返回false，结果如下：

5
false
  • findFirst操作
 		/**
         * findFirst：获取第一个对象
         * 短路的  获取了就返回
         */
        Optional<User> first = list.stream()
                .findFirst();
        System.out.println(JSON.toJSONString(first.get(), true));

返回第一个对象，结果如下

{
	"password":"123123",
	"userId":5,
	"userName":"ckhhh"
}
  • findAny操作
		 /**
         * findAny找到任何一个就返回
         * 并行操作时findAny会更快，可能会随机匹配 如果串行一致
         */
        Optional<User> first1 = list.stream()
                .findAny();
        System.out.println(JSON.toJSONString(first1.get(), true));

返回任意一个对象，在串行下和返回第一个对象一样，在并行下就是随机的，结果如下：

{
	"password":"123123",
	"userId":5,
	"userName":"ckhhh"
}
  1. 非短路操作
  • max操作
		 /**
         * max操作：获取最大值
         */
        OptionalDouble max = list.stream()
                .mapToDouble(User::getUserId)
                .max();
        System.out.println(max.getAsDouble());

将用户id列分割出来，将值转为doble，返回最大值，结果如下：

5.0
  • min操作
		/**
         * min操作：获取最小值
         */
        OptionalDouble min = list.stream()
                .mapToDouble(User::getUserId)
                .min();
        System.out.println(min.getAsDouble());

将用户id列分割出来，将值转为doble，返回最小值，结果如下：

1.0
  • count操作
 		/**
         * count操作：获取元素的个数
         */
        long count = list.stream()
                .count();
        System.out.println(count);

统计元素个数，结果如下：

5
  • collect操作
		/**
         *  集合收集器
         */
        List<User> result = list.stream()
                .filter(user -> user.getUserId() > 2)
                .collect(Collectors.toList());
        System.out.println(JSON.toJSONString(result, true));

将id大于2的元素重新写入集合，打印结果如下：

[
	{
		"password":"123123",
		"userId":5,
		"userName":"ckhhh"
	},
	{
		"password":"000000",
		"userId":3,
		"userName":"lisi"
	},
	{
		"password":"99999",
		"userId":4,
		"userName":"wangwu"
	}
]


        /**
         *  分组收集器
         */
        Map<String, List<User>> group = list.stream()
                .collect(Collectors.groupingBy(
                        user -> user.userName));
        System.out.println(JSON.toJSONString(group, true));

将元素按用户名分组后打印，结果如下：

{
	"lisi":[
		{
			"password":"000000",
			"userId":3,
			"userName":"lisi"
		},
		{
			"password":"4324324",
			"userId":2,
			"userName":"lisi"
		}
	],
	"ckhhh":[
		{
			"password":"123123",
			"userId":5,
			"userName":"ckhhh"
		}
	],
	"zhangsan":[
		{
			"password":"1232312",
			"userId":1,
			"userName":"zhangsan"
		}
	],
	"wangwu":[
		{
			"password":"99999",
			"userId":4,
			"userName":"wangwu"
		}
	]
}


        /**
         * 分区收集器
         * 分为大于2和小于等于2两部分
         */
        Map<Boolean, List<User>> partition = list.stream()
                .collect(Collectors.partitioningBy(user -> user.getUserId() > 2));

        System.out.println(JSON.toJSONString(partition, true));

将元素按id大于2位标准分为两个区后进行打印，结果如下：

{false:[
		{
			"password":"1232312",
			"userId":1,
			"userName":"zhangsan"
		},
		{
			"password":"4324324",
			"userId":2,
			"userName":"lisi"
		}
	],true:[
		{
			"password":"123123",
			"userId":5,
			"userName":"ckhhh"
		},
		{
			"password":"000000",
			"userId":3,
			"userName":"lisi"
		},
		{
			"password":"99999",
			"userId":4,
			"userName":"wangwu"
		}
	]
}

构建流

  • 由数值直接构建流
public void steamFromValue() {
    Stream stream = Stream.of(1, 2, 3, 4, 5);

    stream.forEach(System.out::println);
}

运行结果如下：

1
2
3
4
5
  • 由数组构建流
 public void streamFromArray() {
        int[] num = new int[]{1, 2, 3, 4, 5};
        Arrays.stream(num)
                .forEach(System.out::println);
  }

运行结果如下：

1
2
3
4
5
  • 通过文件构建流
public void streamFromFile() throws IOException {
        Stream<String> stream = Files.lines(Paths.get("F:/QQ下载/FileServer.java"));
        stream.forEach(System.out::println);
}

运行结果如下（部分）

package com.demo.lambda;

import java.io.*;

/**
 * 〈文件服务类〉
 *
 * @author Chkl
 * @create 2020/4/20
 * @since 1.0.0
 */
public class FileServer {

    /**
     * 通过url获取本地文件内容
     *
     * @param url
     * @param fileConsumer
     */
    public void fileHandler(String url, FileConsumer fileConsumer) throws IOException {
	..............
	...............
  • 通过函数生成流(无限流）
public void streamFromFunction() {
        //参数： 初始值，规则（从0开始生成偶数）
        Stream<Integer> stream = Stream.iterate(0, n -> n + 2);
        stream.limit(100)
                .forEach(System.out::println);
        //随机生成
        Stream<Double> stream2 = Stream.generate(Math::random);
        stream2.limit(100)
                .forEach(System.out::println);

}

第一种运行结果如下（部分）：

0
2
4
6
8
10
12
14
16
18
20
22
24

第二种运行结果如下（部分）：

0.28047181698982915
0.3366379505477519
0.6314896823002529
0.4202209521644461
0.8362832087391032
0.7025533309035066
0.49208504805565545
0.18517793464530763
0.37580620856029856
0.8888281509032474
0.8399345540793907
0.6470816912713735
0.9842389606178953
0.5166615554196825
0.035214233629631164

通过以上的学习，可以基本的掌握Stream流常用的一些操作和构建方便了，具体业务需要使用到的方法在使用时再去了解

clonechen2021
关注
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
新的特性使得数据处理更加直观本教程将带你逐步了解如何使用Java Stream API
最新发布
王大师企业官方博客
06-30 4029
Java的Stream是一个表示元素序列的抽象概念，你可以通过它执行复杂的查找、过滤和映射数据等操作。流与集合（如List、Set等）不同，它们的主要区别在于：流不支持索引访问，是一次性的，且无法被修改。
万字详解 | Java 流式编程
20年码农
04-12 1662
Stream API 是 Java 中引入的一种新的数据处理方法。它提供了一种高效且易于使用的方法来处理数据集合。在大多数情况下，将对象存储在集合中就是为了处理它们，因此你会发现你把编程 的主要焦点从集合转移到了流上。当 Lambda 表达式和方法引用（method references），流（Stream）结合使用的时候会让人感觉自成一体，行云流水的感觉// 随机展示 5 至 20 之间不重复的整数并进行排序.distinct() // 使流中的整数不重复。
Java流式编程
蓝天⊙白云的博客
06-17 1239
什么是流式编程 对于java来说，我们最常用的面向对象编程属于命令式编程（Imperative Programming）这种编程范式。常见的编程范式还有逻辑式编程（Logic Programming），函数式编程（Functional Programming）。函...
JAVA流式编程
heijunwei的博客
02-13 1102
前言： java8中有两大最为重要的改变。第一个是Lambda 表达式；另外一个则是Stream API(java.util.stream.*)。Stream 是Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用SQL 执行的数据库查询。也可以使用Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且...
Java中的流式编程
qq_37461349的博客
05-26 1万+
！！！！！！！！！注意：这个特效是在Java8之后才引进的  就是说 jdk8之前是没有的一. 基本概念1.1 为什么加入 集合的流式操作             JDK8 的Stream 是一个受到 函数式编程 和 多核时代影响而产生的东西。很多时候我们需要到底层返回数据，上层再对数据进行遍历，进行一些数据统计，但是之前的Java API 中很少有这种方法，这就需要我们自己来 Iterator ...
JAVA进阶笔记之Stream-方法引用(推荐)
王大师企业官方博客
01-11 421
学习目标 1、一周掌握 JAVA入门到进阶知识 2、掌握基础C#l窗体知识 3、手把手教你vbs脚本制作 4、强大的 IDEA编程利器 5、经典少见的 面试题目技巧 JAVA进阶笔记之Stream-方法引用（推荐）学习目标第一章 Stream流1.1 引言1.2 流式思想概述1.3 获取流1.4 常用方法1.5 练习：集合元素处理（传统方式）1.6 练习：集合元素处理（Stream方式）第二章 方法引用2.1 冗余的Lambda场景2.2 问题分析2.3 用方法引用改进代码2.4 方法引用符2.5 通..
2024年网络安全最新【Java基础知识 1】Java入门级概述(1)
2401_84281638的博客
05-03 979
为了解决困难，他们首先着眼于语言的开发， 对于新语言的设计，Sun公司研发人员并没有开发一种全新的语言，而是根据嵌入式软件的要求，对C++进行了改造，去除了留在C++的一些不太实用及影响安全的成分，并结合嵌入式系统的实时性要求，开发了一种称为Oak的面向对象语言。Java的程序也就是我们编译的代码都会编译为class文件，class文件就是在jvm上运行的文件，只有JVM还不能完全支持class的执行，因为在解释class的时候JVM需要调用解释所需要的类库lib，而jre包含lib类库。
【项目实战】并发编程之CompletableFuture入门介绍
本本本添哥
07-17 283
CompletableFuture 是 Java 8 中引入的一个用于支持异步编程的类，它提供了一种方便的方式来执行异步任务，并可以通过链式调用的方式将多个任务串联起来。CompletableFuture 是一个实现了 Future 接口的类，它允许我们执行异步任务、等待任务完成并获取任务的结果。
Java中的流式编程(Stream)
尘风yf的博客
02-04 1294
Stream是Java 8 的新功能，是对集合(Collection)对象功能的增强，可以非常方便地对集合中的对象进行操作。与Lambda表达式结合，可以提高编程效率、代码的简洁性与可读性。Stream流其实是一个集合元素的函数模型，它并不是集合，也不是数据结构，其实本身并不存储任何元素Stream是一个来自数据源的元素队列。
java中的流式编程
Shawsw的博客
08-07 271
在Java 8中得益于lambda所带来的函数是编程，便引入了全新的Stream概念，用于解决集合类库中已有的弊端。 分析： .stream() ： 转化为流
java流式编程_Java 流式写法
weixin_30941215的博客
02-22 1231
本文列举了十个使用一行代码即可独立完成(不依赖其他代码)的业务逻辑，主要依赖的是Java8中的Lambda和Stream等新特性以及try-with-resources、JAXB等。对列表/数组中的每个元素都乘以2123// Range是半开区间int[] ia = range(1, 10).map(i -> i * 2).toArray();List result = range(1, 1...
Java流编程实例之一--Java中的字节与字符
LogicTeamLeader的专栏
09-04 1589
1.前言在众多流行的编程语言中，Java对IO的处理应该是最特殊的，Java打着“尽量减少IO类的设计理念”，搞出了目前应该是最复杂的一套IO相关类，并称之为Java流。 对于新手来说，Java流包含的类众多，含义混杂，上手困难且其中暗藏的陷阱众多；但是对于熟悉了Java流的程序员来说，它的确称得上功能强大。 本文总结了一些Java流的使用指南，给出了一些实例代码，主要内容包括： - Jav
Java8：流式编程
horinjsor的博客
11-28 1395
本文介绍Java8的特性之【流式编程】。提示：以下是本篇文章正文内容，下面案例可供参考冲。lambda之Stream流式编程java8之Stream流处理。
Java流式编程详解
热门推荐
CodePanda@GPF的博客
04-07 1万+
Java流式编程、Stream
Java流编程实例之二--文件流
LogicTeamLeader的专栏
09-07 1518
3. 文件流3.1 如何选择文件流的类文件流应该是Java流中使用最普遍、最广泛的流了。文件流分为两组，一组是操作字节的FileInputStream和FileOutputStream，另一组是操作字符的FileReader和FileWriter，事实上，我们还经常用到FileReader和FileWriter的父类InputStreamReader和OutputStreamWriter，原因后
Java流编程实例之八--摘要流
LogicTeamLeader的专栏
11-22 1185
9. 摘要流摘要流在对一组信息进行输入输出操作的同时，将摘要信息记录下来，最后通过getMessageDigest().digest()方法得到摘要信息的byte数组。 摘要流示例代码：对字符串进行摘要和对文件进行摘要。import java.io.*; import java.security.DigestOutputStream; import java.security.Message
java8 流式编程详细讲解（一）之 Stream、Collector
nandao158的博客
07-26 3702
Java 8 中引入了新特性，流式编程思想，为其增加了有一个新的亮点！因为流的一个核心好处是，使得代码程序更加精简并且更易理解。在某些数情况下，将对象存储在数组、集合中是为了处理他们，而现在你可以把编程的主要焦点从其转移到了流上，使得java更具有吸引力。下面看一些实例： 1、随机展示 1至 50 之间不重复的整数并进行排序。实际上，你的关注点首先是创建一个有序集合。使用流式编程，你就可以简单...
Java 8新流Stream抽象：声明式数据处理利器
这种声明式编程风格极大地提升了代码的可读性，因为程序员只需描述处理数据的方式，而不需要关心具体的执行细节。 例如，下面的代码片段展示了如何使用 Stream API 来过滤一个整数列表，只保留偶数并计算它们的和：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值