Java常用的stream流操作，附源码

已于 2023-06-13 18:40:34 修改
阅读量1.3w 收藏 13
点赞数 5
分类专栏： java开发常遇问题 文章标签： java 开发语言
于 2022-06-11 16:49:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cucgyfjklx/article/details/125236269
版权

Java常用的stream流操作，附源码

问题背景

java8的新特性非常有亮点，stream用起来爽歪歪
注意事项：

  • 可以自己创建工程，也可以下载源码进行参考

中间操作

  • filter：过滤流中的某些元素,
  • sorted(): 自然排序，流中元素需实现 Comparable 接口 。
  • distinct: 去除重复元素
  • limit(n): 获取 n 个元素
  • skip(n): 跳过 n 元素，配合 limit(n)可实现分页 map(): 将其映射成一个新的元素

终端操作

  • forEach: 遍历流中的元素
  • toArray: 将流中的元素倒入一个数组
  • min: 返回流中元素最小值
  • max: 返回流中元素最大值
  • count: 返回流中元素的总个数
  • reduce: 所有元素求和
  • anyMatch: 接收一个 Predicate 函数，只要流中有一个元素满足条件则返 回 true，否则返回 false
  • allMatch: 接收一个 Predicate 函数，当流中每个元素都符合条件时才返 回 true，否则返回 false
  • findFirst：返回流中第一个元素
  • collect: 将流中的元素倒入一个集合,Collection 或 Map

stream操作方法

导入类

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.apache.commons.lang3.ArrayUtils;

import static java.util.Comparator.comparing;
import static java.util.stream.Collectors.collectingAndThen;
import static java.util.stream.Collectors.toCollection;
1 去重
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("a");
        List<String> listDistinct = list.stream().distinct().collect(Collectors.toList());
        System.out.println(listDistinct);
2 对象无序去重, 通过name去重
        List<User> userList = new ArrayList();
        userList.add(new User("yuange", 12));
        userList.add(new User("yuange", 12));
        userList.add(new User("yuange1", 14));
        userList.add(new User("yuange1", 15));
        userList.add(new User("pangpang", 12));
        userList.add(new User("pangpang", 12));
        List<User> result = userList.stream()
                .collect(collectingAndThen(toCollection(() ->
                        new TreeSet<>(comparing(User::getName))), ArrayList::new));
        result.forEach(System.out::println);
3 对象无序去重, 通过name且age去重，注意：不是先使用name去重，再使用age去重
        List<User> result1 = userList.stream()
                .collect(collectingAndThen(toCollection(() ->
                        new TreeSet<>(comparing(o -> o.getName() + ";" + o.getAge()))), ArrayList::new));
        result1.forEach(System.out::println);
3.1 对象有序去重
public class StreamUtils{


	//LinkedHashMap有序去重
	private static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
	        LinkedHashMap<Object, Boolean> map = new LinkedHashMap<>();
	        return t -> map.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
	}
	
	//ConcurrentHashMap无序去重
	private static <T> Predicate<T> distinctByKeyMap(Function<? super T, Object> keyExtractor) {
	        ConcurrentHashMap<Object, Boolean> map = new ConcurrentHashMap<>();
	        return t -> map.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
	}
}

List<User> list = new ArrayList<User>();
list.add(new User("小南", 23, "18335888888"));
list.add(new User("小南", 22, "18335888888"));
list.add(new User("小南", 21, "18335888888"));
list.add(new User("小南", 20, "18335888888"));

list = list.stream().filter(StreamUtils.distinctByKey(User :: getName)).collect(Collectors.toList());
System.out.println(list.toString());
4 整个对象去重, 使用distinct需要重写User的equals和hashcode
        List<User> result2 = userList.stream().distinct().collect(Collectors.toList());
        result2.forEach(System.out::println);
5 流的基本操作
        Integer[] integers = new Integer[]{2, 4, 3, 6, 1, 7, 5, 5, 7};
        List<Integer> list1 = Arrays.asList(integers);
        //list1.stream()等价于Stream.of(2,4,3,6,1,7,5,5,7)
        list1.stream()
                //中间操作
                .filter((e) -> {
                    return e > 3;
                })      //使用Lambda的表达式  表示大于3的留下
                //filter的结果为 4,6,7,5,5,7
                .sorted()                           //自然排序，流中元素需实现
                //sorted的结果为 4,5,5,6,7,7
                .distinct()                         //去除重复元素
                //distinct的结果为 4,5,6,7
                .skip(1)                            //跳过 n 元素   这里意思跳过1个元素，从第二个开始
                //skip的结果为 5,6,7
                .limit(2)                           //获取 n 个元素 这里获取了两个元素
                //limit的结果为 5,6
                //终端操作
                .forEach((a) -> {
                    System.out.println(a);
                });
6 取出List中某个属性值
        ArrayList<User> arrayList = new ArrayList<>();
        arrayList.add(new User("小智", 12));
        arrayList.add(new User("张三", 12));
        arrayList.add(new User("蕾姆", 14));
        arrayList.add(new User("亚当", 11));
        arrayList.add(new User("夏娃", 7));
        arrayList.stream()
                //map（方法）将某一个值映射到Stream
                //Apple::getNumber意思是将Apple对象中的number 转换为Stream中的流
                .map(User::getName)
                //之下的操作就是对Apple中所有的number数据进行操作
                .forEach((e) -> {
                    System.out.println(e);
                });

arrayList.stream().map(User::getName).collect(Collectors.toList());
7 转为排序的list
        List<User> list2 = arrayList.stream()
                //中间操作，进行了一个排序的操作
                .sorted((o1, o2) -> {
                    return o1.getAge() - o2.getAge();
                })
                .collect(Collectors.toList());//将处理完后的流转换为List类型的数据
        System.out.println("转换为一个List的集合：");
        System.out.println(list);
8 转为set集合
        Set<User> set = arrayList.stream()
                //中间操作，进行了一个排序的操作
                .collect(Collectors.toSet());//将处理完后的流转换为List类型的数据
        System.out.println("转换为一个Set的集合：");//set就是不重复
        System.out.println(set);
9 转为map
        Map<String, Integer> map = arrayList.stream()
                //中间操作，进行了一个排序的操作
                .collect(Collectors.toMap(User::getName, User::getAge));//将处理完后的流转换为List类型的数据
        System.out.println("转换为map的结果：");
        System.out.println(map);
10 转换为一个数组
        Object[] array = list1.stream().sorted().toArray();
        System.out.println(Arrays.toString(array));
11 取出最大值
        Integer max = Stream.of(2, 4, 3, 6, 1, 7, 5)
                //中间操作
                .sorted()   //自然排序
                //sorted的结果为 1,2,3,4,5,6,7
                //终端操作
                .max((o1, o2) -> {
                    return o1 - o2;
                })//max的返回值是一个Optional这样的对象中
                //再调用Optional中的get的这个方法，将值拿到就行了
                .get();
        System.out.println(max);
12 取出最小值
        Integer min = Stream.of(2, 4, 3, 6, 1, 7, 5)
                //中间操作
                .sorted()   //自然排序
                //sorted的结果为 1,2,3,4,5,6,7
                //终端操作
                .min((o1, o2) -> {
                    return o1 - o2;
                })//min和max一样同理
                .get();
        System.out.println(min);
13 返回总个数
        long count = Stream.of(2, 4, 3, 6, 1, 7, 5)
                //中间操作
                .sorted()   //自然排序
                //sorted的结果为 1,2,3,4,5,6,7

                //终端操作
                .count();//count返回的总共有多少个数据元素
        System.out.println(count);
15 求总和
        Integer reduce = Stream.of(2, 4, 3, 6, 1, 7, 5)
                //中间操作
                .sorted()   //自然排序
                //sorted的结果为 1,2,3,4,5,6,7
                //终端操作
                .reduce((o1, o2) -> {
                    return o1 + o2;
                })//count返回的总共有多少个数据元素
                .get();
        System.out.println(reduce);
16 anyMatch：只要流中有一个元素满足条件则返 回 true，否则返回 false
        boolean anyMatch = Stream.of(2, 4, 3, 6, 1, 7, 5)
                //中间操作
                .sorted()   //自然排序
                //sorted的结果为 1,2,3,4,5,6,7

                //终端操作
                .anyMatch((e) -> {
                    return e > 3;
                });//表示流中的元素只要有一个大于3就返回true
        System.out.println("angMatch:" + anyMatch);
17 allMatch: 当流中每个元素都符合条件时才返 回 true，否则返回 false
        boolean allMatch = Stream.of(2, 4, 3, 6, 1, 7, 5)
                //中间操作
                .sorted()   //自然排序
                //sorted的结果为 1,2,3,4,5,6,7
                //终端操作
                .allMatch((e) -> {
                    return e > 3;
                });//表示流中的元素全部都大于3才返回true
        System.out.println("allMatch:" + allMatch);
18 取出第一个元素
         Integer findFirst = Stream.of(2, 4, 3, 6, 1, 7, 5)
                //中间操作
                .sorted()   //自然排序
                //sorted的结果为 1,2,3,4,5,6,7
                //终端操作
                .findFirst()    //findFirst的终端操作也用的是Optional的对象
                .get();         //要对数据进行输出，所以也要用的get的方法
        System.out.println("findFirst：" + findFirst);
19 数组与list的相互转换
        int[] array1 = {1, 2, 5, 5, 5, 5, 6, 6, 7, 2, 9, 2};
        /* int[] 转 list */
        //方法一：需要导入commons-lang3依赖  ArrayUtils.toObject把int转为Integer
        List<Integer> list3 = Arrays.asList(ArrayUtils.toObject(array1));
        //方法二：java8及以上版本 boxed()转为Integer
        List<Integer> list4 = Arrays.stream(array1).boxed().collect(Collectors.toList());
        System.out.println(list3);
        System.out.println(list4);
        System.out.println();

        /* list 转 int[]*/
        //方法一：
        Integer[] intArr = list3.toArray(new Integer[list3.size()]);
        //方法二：java8及以上版本
        int[] intArr1 = list3.stream().mapToInt(Integer::valueOf).toArray();
        System.out.println(Arrays.toString(intArr));
        System.out.println(Arrays.toString(intArr1));

        //数组为Integer类型
        Integer[] array2 = {1, 2, 5, 5, 5, 5, 6, 6, 7, 2, 9, 2};
        List<Integer> list5 = Arrays.asList(array2);
        System.out.println(list5);
20 name为key，age为value，如果key重复，取后一个v2值
userMap = userList.stream().collect(Collectors.toMap(User::name, User-> User, (v1, v2) -> v2));
21 升序排序
// 根据age排序 （正序）
list = list.stream().sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList());
//输出
//[User(name=小南, age=20, phone=18335888888), User(name=小南, age=21, phone=18335888888), User(name=小南, age=22, phone=18335888888), User(name=小南, age=23, phone=18335888888)]
// （倒序）
list = list.stream().sorted(Comparator.comparing(User::getAge).reversed()).collect(Collectors.toList());
//输出
//[User(name=小南, age=23, phone=18335888888), User(name=小南, age=22, phone=18335888888), User(name=小南, age=21, phone=18335888888), User(name=小南, age=20, phone=18335888888)]
//如果排序字段为空将空的某一条默认排到开头还是结尾
//放到结尾
list = list.stream().sorted(Comparator.comparing(User::getAge,Comparator.nullsLast(Integer::compare).reversed())).collect(Collectors.toList());
//放到开头
list = list.stream().sorted(Comparator.comparing(User::getAge,Comparator.nullsFirst(Integer::compare).reversed())).collect(Collectors.toList());
22 降序排序
stream流降序
list.stream().sorted(Comparator.reverseOrder())
stream流根据某一字段降序
list.stream().sorted(Comparator.comparing(User::getAge).reversed())
23 排序并去重
//需要使用文章上面的工具类StreamUtils
list = list.stream().sorted(Comparator.comparing(User::getAge,Comparator.nullsLast(Integer::compare).reversed())).filter(StreamUtils.distinctByKey(User :: getName)).collect(Collectors.toList());
24 根据两个字段排序
list.stream().sorted(Comparator.comparing(User::getAge).thenComparing(User::getName)).collect(Collectors.toList());
25 根据中文字段排序
list.stream().sorted(Comparator.comparing(User::getChName,Collator.getInstance(Locale.CHINA))).collect(Collectors.toList());
26 通过对象里面的某个字段进行分组
Map<Long, List<Keyword>> keywords = keywordService.getKeywordsByPaperId(paperIds).stream().collect(Collectors.groupingBy(Keyword::getPaperId));
27 通过对象里面的某个字段映射为Map
Map<String, Item> itemMap = itemList.stream().filter(t -> StringUtils.isNotEmpty(t.getCode())).collect(Collectors.toMap(Item::getCode, Function.identity()));
28 List转为List
list.stream().map(s -> Long.parseLong(s.trim())).collect(Collectors.toList());

处理返回LongStream；LongStream.boxed 将 LongStream 转换为 Stream ，然后收集到列表中

list.stream().mapToLong(t -> Long.parseLong(t.trim())).boxed().collect(Collectors.toList());
29 List转为List
list.stream().map(String::valueOf).collect(Collectors.toList());

总结

  • 有用到新的就来更新




作为程序员第 163 篇文章，每次写一句歌词记录一下，看看人生有几首歌的时间，wahahaha …

Lyric： 包括像猫的狗

时间是一种解药
关注
  • 5
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java8stream源码-JPP:JPP
06-04
stream 源码 JPP JPP - Java Promotion Process 是一个Java能力提升的计划，与君共勉 在这里： 你可以记录有趣的案例Demo 你可以链接有深度的博客文章 你可以分享自己的学习历程 这个计划需要你们的加入 Peace~Yo ...
java8stream源码-blade:刀
06-04
java8流源码 基于Java8 + Netty4打造轻量级、高性能、简洁优雅的Web框架 :face_savoring_food: 花1个小时学习它做一些有趣的事情，是除了Spring框架的最佳选择。 :paw_prints: | :blue_book: | :clapper_board: | :...
java 每次添加新的值_java – 向现有Stream添加新值
weixin_42522857的博客
02-26 628
是否有一个很好的方法来添加一个新的值现有的流？我可以想象的是这样的：public Stream addToStream(Stream stream, T elem ) {List result = stream.collect(Collectors.toList());result.add(elem);return result.stream();}但我正在寻找一些更简洁的东西，我可以在lamb...
学习笔记（一）：Java中Stream的基本用法和相关API详解
weixin_52279910的博客
07-02 2090
在学习Kotlin语言的过程中，有被Kotlin中函数式编程的语法糖甜到，因此学习了Kotlin“本家”，Java相关的函数式编程知识。在学习Lambda表达式时接触到了Stream，通过阅读Java文档，博客等方式学习了相关API并且自己实操后，决定记录自己学习成果，也向不知道Stream的同学介绍一些Stream相关知识。...
Stream流常用操作
最新发布
码砖师傅的博客
05-19 874
Java Stream流
Java8 Stream流的常用方法和讲解
m0_71355126的博客
06-24 745
Java8 Stream 中如何使用和一些常用方法
JDK 8 Stream 数据流效率怎么样？
Java技术栈，分享最主流的Java技术
04-10 345
Stream 是Java SE 8类库中新增的关键抽象，它被定义于 java.util.stream （这个包里有若干流类型：Stream<T> 代表对象引用流，此外还有一系列特化流，如 IntStream，LongStream，DoubleStream等。 Java 8 引入的的Stream主要用于取代部分Collection的操作，每个流代表一个值序列，流提供一系列常用的聚集操作，可以便捷的在它上面进行各种运算。集合类库也提供了便捷的方式使我们可以以操作流的方式使用集合、数组以及其它数据结构
Java8新特性 Stream流常用方法
weixin_44338615的博客
06-26 3351
Java8 API添加一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。 Stream使用一种类似用SQL语句从数据库中查询数据的直观方式来提供一种对Java集合运算和表达的高阶抽象。 Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。 这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选，排序，聚合等。 元素流在管道中经过中间操作(intermediate operation）的处理，最后由最终操作得到前
Stream流(笔记)
weixin_44784393的博客
03-27 1336
一.Sream流概述 我们可以把集合|数组,转换为Stream流,使用Stream流中的方法,对集合|数组进行操作 作用:简化代码,使我们的代码更加优雅 2.Stream流的基本体验 需求: List list= new ArrayList<>(); Collections.addAll(list,“张无忌”,“周芷若”,“赵敏”,“张三丰”,“张翠山”,“灭绝师太”,“张三”); 1.首先晒选出所有姓张的人,把姓张的人存储到一个新的集合中 2.筛选名字中是3个字的人,把名字是3个字的人存储到一
在stream中使用foreach对集合进行add显示无法处理not fianl变量
Monicz的博客
10-20 622
Copy 'list' to effectively final temp variable; 在流中使用foreach对集合进行操作之前有进行操作
Java链式编程（Stream流）
shuangmu_chenglin的博客
04-20 1096
Java链式编程示例 java.util.Stream 表示能应用在一组元素上一次执行的操作序列。Stream 操作分为中间操作或者最终操作两种，最终操作返回一特定类型的计算结果，而中间操作返回Stream本身，这样你就可以将多个操作依次串起来。通过Stream中的常用函数Filter(过滤)、Map(映射)、Sort(排序)、**Count(计数)**等常用函数接口，我们可以很方便的对数据流处理，极大地简化编程，提高代码可读性。 Filter(过滤):将数据流中满足过滤条件的数据筛选出来 Map(映
Stream流的常用方法
热门推荐
DQ6667的博客
04-11 4万+
1、快速创建List List list = Stream.of("1", "2").collect(Collectors.toList()); 2、取对象的某一列 低效方式： List<String> userNameList = new ArrayList<>(); for (String) List<String> userNameList = list.stream().map(User::getName).collect(Collectors.toList(
Java Stream类常见用法
sc179的博客
08-31 2920
Java Stream类常见用法
java8stream源码-ss:SS
06-04
java8流源码 基于Java8 + Netty4打造轻量级、高性能、简洁优雅的Web框架 :face_savoring_food: 花1个小时学习它做一些有趣的事情，是除了Spring框架的最佳选择。 :paw_prints: | :blue_book: | :clapper_board: | :...
java8stream源码-padma:帕德玛
06-04
java8流源码 基于Java8 + Netty4打造轻量级、高性能、简洁优雅的Web框架 :face_savoring_food: 花1个小时学习它做一些有趣的事情，是除了Spring框架的最佳选择。 :paw_prints: | :blue_book: | :clapper_board: | :...
java8stream源码-blade20190422:刀片20190422
06-04
java8流源码 基于Java8 + Netty4打造轻量级、高性能、简洁优雅的Web框架 :face_savoring_food: 花1 小时学习它来做一些有趣的事情，这是除其他可用框架之外的工具。 :paw_prints: | :clapper_board: | :new_moon_...
Stream流的基本操作（JDK 1.8 新特性之Stream）
m0_58680865的博客
04-30 1315
stream的相关操作
【java】常用Stream方法
当白的技术小窝 ( git : https://github.com/canwhite )
09-30 5259
常用Stream方法
java8 Stream 常用使用方法
兴浩的博客
06-26 237
1.forEach循环 list.forEach(item -> { }); 1.foreach的实现基于Iterator； 2.不能使用foreach对数组或容器进行赋值； 3.可以使用foreach修改数组或容器的对象的属性； 4.赋值行为尽量使用for循环。 2.java8 stream list转map及问题解决 3.java8 stream 集合取交集、并集、差集、去重并集 public static void main(String[] args) { List<St
java8stream流常用方法
08-30
Java 8中的Stream流提供了许多常用方法，可以帮助我们对数据集合进行处理和操作。下面是一些常用的Java 8 Stream流方法： 1. filter(Predicate): 根据给定的条件过滤流中的元素，并返回一个新的流。 2. map(Function): 将流中的每个元素通过给定的函数进行映射，并返回一个新的流。 3. flatMap(Function): 将流中的每个元素通过给定的函数映射成一个流，然后将所有的流合并成一个流。 4. distinct(): 去除流中重复的元素，返回一个去重后的新流。 5. limit(long): 限制流中元素的数量，返回一个包含指定数量元素的新流。 6. skip(long): 跳过指定数量的元素，返回一个跳过指定数量元素后的新流。 7. sorted(): 对流中的元素进行排序，默认使用自然顺序。 8. sorted(Comparator): 对流中的元素进行排序，使用指定的比较器。 9. forEach(Consumer): 对流中的每个元素执行给定的操作。 10. toArray(): 将流中的元素转换为数组。 这些方法只是Java 8 Stream流中的一部分常用方法，还有很多其他方法可以用于不同的数据处理需求。希望对你有帮助！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值