java8 stream的使用笔记

于 2022-06-01 11:30:22 发布
阅读量305 收藏 2
点赞数 1
分类专栏： javastream示例 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42117260/article/details/125068929
版权

简介

记录stream常用的相关操作

stream的使用

//测试类
public class Test {
    /**
     * 人名
     */
    private String name;

    /**
     * 随机值
     */
    private String code;

    /**
     * 年龄
     */
    private Integer age;

    /**
     * 金额
     */
    private BigDecimal money;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public BigDecimal getMoney() {
        return money;
    }

    public void setMoney(BigDecimal money) {
        this.money = money;
    }
}

测试数据
		List<Test> testList = new ArrayList<>();
		testList.add(new Test("风停", "123", 22, new BigDecimal(12)));
        testList.add(new Test("风停1", "1", 56, new BigDecimal(12)));
        testList.add(new Test("风停2", "444", 23, new BigDecimal(12)));
        testList.add(new Test("风停2", "444", 23, new BigDecimal(12)));
        testList.add(new Test("风停", "666", 68, new BigDecimal(13)));
        testList.add(new Test("风停3", "666", 68, new BigDecimal(13)));

toList()

   List<Integer> collect2 = 	testList.stream().map(Test::getAge).collect(Collectors.toList());
        System.out.println(collect2);
打印结果：
	[22, 56, 23, 23, 68, 68]

map() 从一个集合中抽取某一个属性

	list .stream().map(Test::getName).forEach(e-> System.out.println(e));
打印结果：
	["风停","风停1","风停2","风停"]

forEach()循环的使用

	testList.stream().forEach(e-> System.out.println(e));
        
打印结果：
	Test{name='风停', code='123', age=22, money=12}
	Test{name='风停1', code='1', age=22, money=12}
	Test{name='风停2', code='444', age=23, money=12}
	Test{name='风停', code='666', age=22, money=12}

sorted()排序的使用

	//根据getAge正序
	testList.stream().sorted(Comparator.comparing(Test::getAge)).forEach(e-> System.out.println(e));
	//根据getAge倒叙(正序以后在倒叙)
	testList.stream().sorted(Comparator.comparing(Test::getAge).reversed()).forEach(e-> System.out.println(e));
	//根据getAge倒叙(直接倒叙) 建议使用此方法
	testList.stream().sorted(Comparator.comparing(Test::getAge,Comparator.reverseOrder())).forEach(e-> System.out.println(e));
	//多字段排序
	testList.stream().sorted(Comparator.comparing(Test::getAge,Comparator.reverseOrder()).thenComparing(Test::getMoney,Comparator.reverseOrder())).forEach(e-> System.out.println(e));

filter() 方法过滤

	testList.stream().filter(test -> test.getAge() > 50).forEach(test -> System.out.println(test ));
打印结果：
	Test{name='风停1', code='1', age=56, money=12}
	Test{name='风停', code='666', age=68, money=13}

limit() 获取条数

	testList.stream().limit(2).forEach(test -> System.out.println(test));
打印结果：
	Test{name='风停', code='123', age=22, money=12}
	Test{name='风停1', code='1', age=56, money=12}

skip() 截取前面2条

	testList.stream().skip(2).forEach(test -> System.out.println(test));
打印结果：
	Test{name='风停2', code='444', age=23, money=12}
	Test{name='风停', code='666', age=68, money=13}

distinct() 去重(必须重写hashCode()和equals()方法) 指定字段去重

	testList.stream().distinct().forEach(test -> System.out.println(test));
	//指定字段去重
	List<Test> testList =testList.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(f -> f.getName()+f.getAge()))), ArrayList::new)).forEach(test -> System.out.println(test));

count ，avg,max，min，sum的使用

	int sum = testList.stream().mapToInt(e -> e.getAge()).sum();
	System.out.println("年龄之和：" + sum);
	IntSummaryStatistics intSummaryStatistics = testList.stream().mapToInt(e -> e.getAge()).summaryStatistics();
	System.out.println("总共人数：" + intSummaryStatistics.getCount());
	System.out.println("平均年龄：" + intSummaryStatistics.getAverage());
	System.out.println("最大年龄：" + intSummaryStatistics.getMax());
	System.out.println("最小年龄：" + intSummaryStatistics.getMin());
	System.out.println("年龄之和：" + intSummaryStatistics.getSum());
打印结果：
	年龄之和：260
	总共人数：6
	平均年龄：43.333333333333336
	最大年龄：68
	最小年龄：22
	年龄之和：260

flatMap() 多个list合并为一个list

   		List<Test> testList = new ArrayList<>();
        testList.add(new Test("风停", "123", 22, new BigDecimal(12)));
        testList.add(new Test("风停1", "1", 56, new BigDecimal(12)));
        testList.add(new Test("风停2", "444", 23, new BigDecimal(12)));
        testList.add(new Test("风停2", "444", 23, new BigDecimal(12)));
        testList.add(new Test("风停", "666", 68, new BigDecimal(13)));
        testList.add(new Test("风停3", "666", 68, new BigDecimal(13)));
        List<Test> testList1 = new ArrayList<>();
        testList1.add(new Test("风停", "123", 22, new BigDecimal(12)));
        testList1.add(new Test("风停1", "1", 56, new BigDecimal(12)));
        testList1.add(new Test("风停2", "444", 23, new BigDecimal(12)));
        testList1.add(new Test("风停2", "444", 23, new BigDecimal(12)));
        testList1.add(new Test("风停", "666", 68, new BigDecimal(13)));
        testList1.add(new Test("风停3", "666", 68, new BigDecimal(13)));
        List<List<Test>> aaa = new ArrayList<>();
        aaa.add(testList);
        aaa.add(testList1);
        aaa.stream().flatMap(e->e.stream()).forEach(test -> System.out.println(test));
打印结果：
Test{name='风停', code='123', age=22, money=12}
Test{name='风停1', code='1', age=56, money=12}
Test{name='风停2', code='444', age=23, money=12}
Test{name='风停2', code='444', age=23, money=12}
Test{name='风停', code='666', age=68, money=13}
Test{name='风停3', code='666', age=68, money=13}
Test{name='风停', code='123', age=22, money=12}
Test{name='风停1', code='1', age=56, money=12}
Test{name='风停2', code='444', age=23, money=12}
Test{name='风停2', code='444', age=23, money=12}
Test{name='风停', code='666', age=68, money=13}
Test{name='风停3', code='666', age=68, money=13}
Test{name='风停', code='123', age=22, money=12}
Test{name='风停1', code='1', age=56, money=12}
Test{name='风停2', code='444', age=23, money=12}
Test{name='风停2', code='444', age=23, money=12}
Test{name='风停', code='666', age=68, money=13}
Test{name='风停3', code='666', age=68, money=13}

findFirst() 获取第一个元素

   Test test = testList.stream().findFirst().get();
   System.out.println(test);
打印结果：
	Test{name='风停', code='123', age=22, money=12}

collect() list转字符串

  		 List<String> list = new ArrayList<>();
        list.add("123");
        list.add("456");
        list.add("789");
        String collect = list.stream().collect(Collectors.joining("-"));
        System.out.println(collect);
        String collect1 = list.stream().collect(Collectors.joining("-","(",")"));
        System.out.println(collect1);
打印结果：
	123-456-789
	(123-456-789)

stream 双重for循环

   		List<Test> testList = new ArrayList<>();
        testList.add(new Test("风停", "123", 222, new BigDecimal(12)));
        testList.add(new Test("风停1", "1", 562, new BigDecimal(12)));
        testList.add(new Test("风停2", "444", 232, new BigDecimal(12)));
        testList.add(new Test("风停2", "444", 232, new BigDecimal(12)));
        testList.add(new Test("风停", "666", 682, new BigDecimal(13)));
        testList.add(new Test("风停3", "666", 682, new BigDecimal(13)));
        List<Test> testList1 = new ArrayList<>();
        testList1.add(new Test("风停", "123", 22, new BigDecimal(12)));
        testList1.add(new Test("风停1", "1", 56, new BigDecimal(12)));
        testList.stream().forEach(e1 -> testList1.stream().anyMatch(e2 -> {
            if(e1.getName().equals(e2.getName())){
                e1.setAge(88);
            }
            return false;
        }));
        System.out.println(testList);
打印结果：
	[Test{name='风停', code='123', age=88, money=12}, Test{name='风停1', code='1', age=88, money=12}, Test{name='风停2', code='444', age=232, money=12}, Test{name='风停2', code='444', age=232, money=12}, Test{name='风停', code='666', age=88, money=13}, Test{name='风停3', code='666', age=682, money=13}]

根据某一字段分组

   List<Test> driverMoneyEntry = driverExpenditureService.getDriverMoneyEntry();
            if (driverMoneyEntry.size() > 0) {
                Map<Long, List<Test>> listMap = driverMoneyEntry.stream().collect(Collectors.groupingBy(Test::getName));
                for (Map.Entry<Long, List<Test>> longListEntry : listMap.entrySet()) {
                    List<Test> expenditureList = longListEntry.getValue();
                    //获取金额
                    String money = expenditureList.stream().map(e -> new BigDecimal(e.getMoney())).reduce(BigDecimal.ZERO, BigDecimal::add).toString();
                }
            }

anyMatch() allMatch() noneMatch()

	//anyMatch 任意匹配就返回true 反之false
	//allMatch 全部匹配就返回true 反之false
	//noneMatch 完全不匹配就返回true 反之false
   boolean isAdmin = testList.stream().anyMatch(r -> "风停".equalsIgnoreCase(r.getName()));
        boolean isAdmin1 = testList.stream().allMatch(r -> "风停".equalsIgnoreCase(r.getName()));
        boolean isAdmin2 = testList.stream().noneMatch(r -> "风停".equalsIgnoreCase(r.getName()));
        System.out.println(isAdmin);
        System.out.println(isAdmin1);
        System.out.println(isAdmin2);
打印结果：
true
false
false

将实体的两个字段封装到map中

   Map<String, String> collect = testList.stream().collect(Collectors.toMap(Test::getName, Test::getCode));
   //有重复的用下面的
   Map<String, String> collect = testList.stream().collect(Collectors.toMap(Test::getName, Test::getCode,(item1,item2) ->item1));
        System.out.println(collect);
打印结果：
{风停3=666, 风停2=444, 风停1=1, 风停=123}
bx风停
关注
专栏目录
Java8 stream学习笔记
一点一滴得积累
09-17 311
public class Main { public static void main(String[] args) { List<Person> data = getData(); // List<Person> data = null; // 将名字变大写 data.stream().map(person...
Java8 Stream学习笔记
liu320yj的博客
04-19 518
Java8中新加入了流（Stream），可以以声明性方式处理数据集合，可以简单的理解成一种新型的遍历数据集的高级迭代器。 流操作有两个重要的特点： 1.流水线------流操作会返回一个流，这样多个操作就可以链接起来，形成一个大的流水线，流水线的操作可以看作对数据源进行数据库式查询。 2.内部迭代------与使用迭代器显式迭代的集合不同，流的迭代操作是在内部进行的。 流操作可以分成两部分，中间操...
java list stream avg_Java 8 Stream API中的多个聚合函数
weixin_35723924的博客
02-13 205
要在没有自定义收集器的情况下执行此操作(不再对结果进行流式传输),您可以这样做.它有点脏,因为它首先收集到Map< String,List< TimePeriodCalc>>然后流式传输该列表并获得平均加倍.由于你需要两个平均值,它们被收集到一个Holder或一对,在这种情况下我使用的是AbstractMap.SimpleEntryMap> map = Stream....
java8 集合骚操作
cmq591117730的博客
09-24 355
首发于 芋道源码 写文章 巧用 Java8 的 Stream 对集合操作飞起来 芋道源码 芋道源码 我的微信公众号：芋道源码。一起知其然，知其所以然。 8 人赞同了该文章 简介 举例说明 filter（筛选） map(转换) distinct(去重) sorted(排序) limit（限制返回个数） skip(删除元素) reduce(聚合) min(求最小值) anyMatch/allMatch/noneMatch（匹配） 总结 《Java 2019 超神之路》 《Dubbo 实现原理与源码解析 —— .
java8 lambda map<list>排序_Java8中的Stream详解
weixin_39655362的博客
11-29 624
java8已经发布相当长一段时间了，我工作中一直维护的几个项目发布在很多环境中，我也不敢保证每个环境的JDK都是1.8版本以上的，也就一直没在工作中使用java8的一些新特性java8刚发布时我学习了一下，写了一些demo，没有及时的进行归档，现在这些demo基本都已经找不到了。在工作中每每遇到对集合进行一些操作时都很头疼，只能不停的对集合进行for循环，有时还需要对同一个集合循环两次以上，不仅效...
java8stream源码-Learning-Note:学习笔记持续更新
06-04
java8 stream 源码 设计模式 单例模式 懒汉 public class SingleTon{ private static SingleTon INSTANCE = null; private SingleTon(){} public static SingleTon getInstance() { if(INSTANCE == null){ INSTANCE ...
【Java8】Lambda表达式 和 Stream API 详解笔记.zip
11-26
Lambda表达式和Stream API的结合使用，使得Java 8在处理集合数据时展现出强大的功能。通过使用这些新特性，开发者可以编写出更加优雅、高效的代码。了解并熟练掌握这两个特性，对于提升Java开发能力至关重要。在实际...
java8实战读书笔记：初识Stream、流的基本操作（流计算）
01-07
本文是博主在学习《java8实战》的一些学习笔记。 从本节开始，将进入到java8 Stream(流)的学习中来。 本文中的部分示例基于如下场景：餐厅点菜，Dish为餐厅中可提供的菜品，Dish的定义如下： 1public class Dish...
java JDK 8学习笔记
09-09
6. **方法引用来代替lambda**：除了使用lambda，Java 8还允许直接引用方法作为参数，这对于已经存在的方法特别有用，无需再次定义。 7. **Optional类**：`Optional<T>`是一个容器对象，可能包含或者不包含非null值...
Java基础 学习笔记 Markdownr版
06-27
5. Java 8新特性：18Java8新特性.md中会涵盖Lambda表达式、函数式接口、Stream API、日期和时间API等Java 8的重要更新，这些新特性极大地简化了代码，增强了Java的表达力。 6. 反射与动态代理：17反射与动态代理.md...
stream filter_用Stream来帮助你更加优雅的处理各种集合数据
weixin_39628945的博客
11-26 490
Stream是Java 8引入的新特性，它配合Java 8的lambda语法能够更加高效和优雅的处理集合。今天我们就来看看Stream的基本用法，下一篇文章详细介绍Stream的实现原理。一个Stream的使用小示例首先我们用一个小示例来直观的感受一下使用Stream和不使用Stream处理集合类的区别。示例中会对一个字符串列表进行处理，首先过滤出字符串长度为4的元素，然后判断是否为小写字母开头，...
Java8 Stream Lambda sorted()之正序倒序
红袖添香的博客
06-02 3832
下面代码以自然序排序一个list list.stream().sorted()
stream流倒序排序_Stream sorted()排序方法的使用示例
weixin_45069056的博客
04-08 1万+
public static int[] intSoret(List<Integer> list){ //倒序 int[] ints = list.stream().sorted(Comparator.reverseOrder()).mapToInt(Integer::intValue).toArray(); //按属性一升序 list.stream().sorted(Comparator.comparing(类::属性一)); //按属性一降序 .
java 8 stream 的使用小总结
qq_33517683的博客
12-13 740
场景1：获取门店列表中Distance最近的两个门店    ---》普通方法，需要写一个算法 /** * 筛选出距离最近的两个门店 * * @Description:TODO * @param shopVO * @return Result * @exception: * @author: 徐正顺 * @time:2017年12月6日 上午11:12:49
java bigdecimal min_java-8 – BigDecimal摘要统计信息
weixin_34284072的博客
03-04 220
我创建了一个this answer的通用摘要统计收集器的BigDecimal特化,它允许扩展它也支持求和,因此也计算平均值：/*** Like {@code DoubleSummaryStatistics}, {@code IntSummaryStatistics}, and* {@code LongSummaryStatistics}, but for {@link BigDecimal}.*/...
readyState属性和status属性
weixin_44492275的博客
09-10 464
readyState属性和status属性 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Document</title> </head> <body
stream流倒序排序_Java 8流逆序
weixin_39928102的博客
12-22 1001
General question: What's the proper way to reverse a stream? Assuming that we don't know what type of elements that stream consists of, what's the generic way to reverse any stream?Specific question:I...
JDK8新特性：使用stream、Comparator和Method Reference实现集合的优雅排序
aty
02-05 2万+
大家对java接口Comparator和Comparable都不陌生，JDK8里面Comparable还和以前一样，没有什么改动；但是Comparator在之前基础上增加了很多static和default方法。本文主要结合JDK的stream编程，学习下Comparator。stream().sorted()/Comparator.naturalOrder()/Comparator.reverseOrder()，要求元素必须实现Comparable接口。
JDK 8 之 Stream sorted() 示例
热门推荐
舒哥的blog
03-19 15万+
原文链接：http://www.concretepage.com/java/jdk-8/java-8-stream-sorted-example 国外对Java8一系列总结的不错， 翻译过来给大家共享 这篇文章将会讲解Java 8 Stream sorted()示例， 我们能够以自然序或着用Comparator 接口定义的排序规则来排序一个流。Comparator 能用用lambada表达式来初
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值