Java集合Stream流操作的基本使用教程分享

Java Stream流操作 Java Stream流 2023-02-21 12:02:24 366人浏览独家记忆

Python 官方文档：入门教程 => 点击学习

摘要

目录事前准备FilterSortedMapMatchCountReduce总结Java 中可以使用 java.util.Stream 对一个集合（实现了java.util.Colle

事前准备

演示 Stream 流的提前准备，创建几个类以供测试

新建一个工具类，方便创建集合。
新建两个类，例如开发中常见的数据库实体类和 DTO 类。

 public class MyUtil {
 
     private static List<String> list = new ArrayList<>();
     private static List<Student> students = new ArrayList<>();
 
     static {
         list.add("abc");
         list.add("xyz");
         list.add("fgh");
         list.add("abc");
         list.add("def");
         list.add("xyz");
         list.add("efg");
 
         Student s1 = new Student();
         s1.setAge("16");
         s1.setId(UUID.randomUUID().toString());
         s1.setName("张三");
         s1.setMajor("计算机科学与技术");
         Student s2 = new Student();
         s2.setAge("18");
         s2.setId(UUID.randomUUID().toString());
         s2.setName("李四");
         s2.setMajor("物联网工程");
         Student s3 = new Student();
         s3.setAge("20");
         s3.setId(UUID.randomUUID().toString());
         s3.setName("王五");
         s3.setMajor("网络工程");
         students.add(s1);
         students.add(s2);
         students.add(s3);
     }
 
     public static List<String> getList() {
         return list;
     }
     public static List<Student> getStudents() {
         return students;
     }
 }
 
 public class Student {
 
     private String id;
     private String name;
     private String age;
     private String major;
     
 }
 
 public class StudentDTO {
 
     private String name;
     private String major;
 }

Filter

filter 可以帮助我们过滤流中的某些元素，其方法签名如下

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

具体使用方法如下：

 public class Main {
 
     public static void main(String[] args) {
         List<String> list = MyUtil.getList();
         System.out.println("过滤操作之前：");
         System.out.println(list);
         // 过滤不以 a 开头的字符串，collect() 将流中的元素放到一个新的集合中
         List<String> newList = list.stream().filter(s -> !s.startsWith("a")).collect(Collectors.toList());
         System.out.println("-------------------------");
         System.out.println("过滤操作之后：");
         System.out.println(newList);
     }
 }
 
 ======== 输出 =========
 过滤操作之前：
 [abc, xyz, fgh, abc, def, xyz, efg]
 -------------------------
 过滤操作之后：
 [xyz, fgh, def, xyz, efg]

Sorted

sorted 可以帮助我们排序流中的元素，方法签名如下：

 
 Stream<T> sorted(Comparator<? super T> comparator);

具体使用方法如下：

 public class Main {
 
     public static void main(String[] args) {
         List<String> list = MyUtil.getList();
         System.out.println("排序操作之前：");
         System.out.println(list);
         List<String> newList = list.stream().sorted().collect(Collectors.toList());
         System.out.println("-------------------------");
         System.out.println("排序操作之后：");
         System.out.println(newList);
         System.out.println("自定义排序：");
         // 倒序排序。 forEach 方法可以用传入的方法 逐个 处理流中的元素
         list.stream().sorted((s1, s2)-> -s1.compareTo(s2)).forEach(System.out::println);
     }
 }
 
 ======== 输出 =========
 排序操作之前：
 [abc, xyz, fgh, abc, def, xyz, efg]
 -------------------------
 排序操作之后：
 [abc, abc, def, efg, fgh, xyz, xyz]
 自定义排序：
 xyz
 xyz
 fgh
 efg
 def
 abc
 abc

Map

Map 操作可以帮助我们将流中的一类元素映射为另一类元素，最典型的应用就是可以用来将数据库实体类转换为供前端使用的 DTO 类。方法签名如下：

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

具体使用方法如下：

 public class Main {
 
     public static void main(String[] args) {
         List<Student> students = MyUtil.getStudents();
         System.out.println("map 操作之前");
         System.out.println(students);
         // collect 方法可以将流中的元素收集到一个 Collection 中，如果有去除重复元素的需求，可以考虑收集到 Set 中
         List<StudentDTO> dtos = students.stream().map(student -> {
             StudentDTO dto = new StudentDTO();
             dto.setName(student.getName());
             dto.setMajor(student.getMajor());
             return dto;
         }).collect(Collectors.toList());
         System.out.println("-------------------------");
         System.out.println("map 操作之后");
         System.out.println(dtos);
     }
 }
 
 ======== 输出 =========
 map 操作之前
 [Student{id='cb5726cd-e73a-443e-95e5-155aa6e876ae', name='张三', age='16', major='计算机科学与技术'}, Student{id='94478bae-b2ee-4c43-bac0-12f45f4099cd', name='李四', age='18', major='物联网工程'}, Student{id='5fdd9e19-f7cf-4c61-b506-0ef58a36dcbe', name='王五', age='20', major='网络工程'}]
 -------------------------
 map 操作之后
 [StudentDTO{name='张三', major='计算机科学与技术'}, StudentDTO{name='李四', major='物联网工程'}, StudentDTO{name='王五', major='网络工程'}]

Match

 
 // 只要集合中有一个匹配，就返回 true
 boolean anyMatch(Predicate<? super T> predicate);
 // 集合中所有元素都匹配，才返回 true
 boolean allMatch(Predicate<? super T> predicate);
 // 集合中所有元素都不匹配，返回 true
 boolean noneMatch(Predicate<? super T> predicate);

具体使用方法如下：

 public class Main {
 
     public static void main(String[] args) {
         List<String> list = MyUtil.getList();
         System.out.println("集合中的所有元素是否都以 a 开头");
         System.out.println(list.stream().allMatch(s -> s.startsWith("a")));
 
         System.out.println("集合中是否存在元素以 a 开头");
         System.out.println(list.stream().anyMatch(s -> s.startsWith("a")));
 
         System.out.println("集合中的元素是否都不以 a 开头（相当于 allMatch 的取反）：");
         System.out.println(list.stream().noneMatch(s -> s.startsWith("a")));
     }
 }
 
 ======== 输出 =========
 集合中的所有元素是否都以 a 开头
 false
 集合中是否存在元素以 a 开头
 true
 集合中的元素是否都不以 a 开头（相当于 allMatch 的取反）：
 false

Count

 
 long count();

具体使用方法如下：

 public class Main {
 
     public static void main(String[] args) {
         List<String> list = MyUtil.getList();
         System.out.println(list);
         System.out.println("集合中的个数：" + list.size());
 
         long count = list.stream().filter(s -> s.startsWith("a")).count();
         System.out.println("集合中以 a 开头的元素个数：" + count);
     }
 }
 
 ======== 输出 =========
 [abc, xyz, fgh, abc, def, xyz, efg]
 集合中的个数：7
 集合中以 a 开头的元素个数：2

Reduce

 
 Optional<T> reduce(BinaryOperator<T> accumulator);

具体使用方法如下：

 public class Main {
 
     public static void main(String[] args) {
         List<String> list = MyUtil.getList();
         // 可以理解为减少集合的个数，对集合中的元素不断进行累加，最终只得到一个元素
         // 例如对数字集合进行累加进行求和
         String s = list.stream().reduce((s1, s2) -> s1 + "###" + s2).get();
         System.out.println(s);
     }
 }
 
 ======== 输出 =========
 abC###xyz###fgh###abc###def###xyz###efg

总结

可以看到，stream 流操作并没有什么使用难度，但如果不熟悉 Lambda 表达式开发和函数引用，则使用起来可能会稍微吃力些。

置于并发流的使用，只需要使用集合的方法parallelStream()，就可以获得一个并发流，在编写代码上基本和同步流没什么区别，因此学会上面的基本用法基本足够了，实际使用过程中，根据实际情况决定如何使用即可。

以上就是Java集合Stream流操作的基本使用教程分享的详细内容，更多关于Java Stream流操作的资料请关注编程网其它相关文章！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: Java集合Stream流操作的基本使用教程分享

本文链接: https://www.lsjlt.com/news/196931.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

Java集合Stream流操作的基本使用教程分享

目录事前准备FilterSortedMapMatchCountReduce总结Java 中可以使用 java.util.Stream 对一个集合（实现了java.util.Colle...

99+

2023-02-21

Java Stream流操作 Java Stream流
Spring内存缓存Caffeine的基本使用教程分享

目录项目配置使用实例1.手动加载2.自动加载3.异步手动加载4.异步自动加载项目配置依赖首先搭建一个标准的SpringBoot项目工程，相关版本以及依赖如下本项目借助Sprin...

99+

2023-03-24

Spring内存缓存Caffeine使用 Spring内存缓存Caffeine Spring Caffeine
stream流的使用-获取list集合中对象的单个字段list集合，进行累加操作

Stream流的使用场景及代码案例源于实际项目 1. 需求描述现存一list集合，其中保存了投资人的信息。 Person （name, age, money rateOfReturn） ...

99+

2023-09-08

java lambda Stream流 stream java8
Android的HTTP操作库Volley的基本使用教程

以前原本都用android内建的Library来进行GET、POST等等对API的连线与操作。但最近想说来找找看有没有好用的library，应该可以事半功倍。当初有找了三套...

99+

2022-06-06

HTTP volley 教程 Android
安装使用Mongoose配合Node.js操作MongoDB的基础教程

安装mongoose 使用express准备一个TestMongoDB项目，命令序列如下： express TestMongoDB cd TestMongoDB npm install 执行完上面的...

99+

2022-06-04

基础教程操作 Node
Python程序中用csv模块来操作csv文件的基本使用教程

CSV全称为“Comma Separated Values”,是一种格式化的文件，由行和列组成，分隔符可以根据需要来变化。如下面为一csv文件： Title,Release Date,Director...

99+

2022-06-04

中用模块操作