lamda流编程

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量183 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ys3198/article/details/117821288
版权
本文详细介绍了Java中Lambda表达式的实用操作，如filter、map、flatMap、peek、sort、distinct等，以及reduce和collect方法在流编程中的应用。通过实例展示了如何进行数据过滤、转换、去重、排序和聚合操作，帮助提升代码效率和可读性。
摘要由CSDN通过智能技术生成

lamda表达式的流编程在项目中基本上也是很常用的了，这次对常用的一些表达式进行一些记录加深自己的印象，让自己的代码看起来更加的高端大气上档次 哈哈哈哈哈

在这里插入图片描述

filter

list.stream()

                // filter
                .filter(sku ->
                        SkuCategoryEnum.BOOKS
                                .equals(sku.getSkuCategory()))

                .forEach(item ->
                        System.out.println(
                                JSON.toJSONString(
                                        item, true)));

map

使用：将一个元素转换成另一个元素

list.stream()

                // map
                .map(sku -> sku.getSkuName())

                .forEach(item ->
                        System.out.println(
                                JSON.toJSONString(
                                        item, true)));

flatMap

使用：将一个对象转换成流

 list.stream()

                // flatMap
                .flatMap(sku -> Arrays.stream(
                        sku.getSkuName().split("")))

                .forEach(item ->
                        System.out.println(
                                JSON.toJSONString(
                                        item, true)));

peek

使用：对流中元素进行遍历操作，与forEach类似，但不会销毁流元素

  list.stream()

                // peek
                .peek(sku -> System.out.println(sku.getSkuName()))

                .forEach(item ->
                        System.out.println(
                                JSON.toJSONString(
                                        item, true)));

sort

使用：对流中元素进行排序，可选则自然排序或指定排序规则。有状态操作

list.stream()

                .peek(sku -> System.out.println(sku.getSkuName()))

                //sort
                .sorted(Comparator.comparing(Sku::getTotalPrice))

                .forEach(item ->
                        System.out.println(
                                JSON.toJSONString(
                                        item, true)));

distinct

使用：对流元素进行去重。有状态操作

list.stream()
                .map(sku -> sku.getSkuCategory())

                // distinct
                .distinct()

                .forEach(item ->
                        System.out.println(
                                JSON.toJSONString(
                                        item, true)));

skip

使用：跳过前N条记录。有状态操作

list.stream()

                .sorted(Comparator.comparing(Sku::getTotalPrice))

                // skip
                .skip(3)

                .forEach(item ->
                        System.out.println(
                                JSON.toJSONString(
                                        item, true)));

limit

使用：截断前N条记录。有状态操作

 list.stream()
                .sorted(Comparator.comparing(Sku::getTotalPrice))

                .skip(2 * 3)

                // limit
                .limit(3)

                .forEach(item ->
                        System.out.println(
                                JSON.toJSONString(
                                        item, true)));

allMatch

使用：终端操作，短路操作。所有元素匹配，返回true

  boolean match = list.stream()

                .peek(sku -> System.out.println(sku.getSkuName()))

                // allMatch
                .allMatch(sku -> sku.getTotalPrice() > 100);

anyMatch

使用：任何元素匹配，返回true

boolean match = list.stream()

                .peek(sku -> System.out.println(sku.getSkuName()))

                // anyMatch
                .anyMatch(sku -> sku.getTotalPrice() > 100);

noneMatch
使用：任何元素都不匹配，返回true

boolean match = list.stream()

                .peek(sku -> System.out.println(sku.getSkuName()))

                // noneMatch
                .noneMatch(sku -> sku.getTotalPrice() > 10_000);

findFirst

找到第一个

 Optional<Sku> optional = list.stream()

                .peek(sku -> System.out.println(sku.getSkuName()))

                // findFirst
                .findFirst();

findAny

找任意一个

Optional<Sku> optional = list.stream()

                .peek(sku -> System.out.println(sku.getSkuName()))

                // findAny
                .findAny();

max

使用：数字类型的才可以使用max

 OptionalDouble optionalDouble = list.stream()
                // 获取总价
                .mapToDouble(Sku::getTotalPrice)

                .max();

min

使用

  OptionalDouble optionalDouble = list.stream()
                // 获取总价
                .mapToDouble(Sku::getTotalPrice)

                .min();

count

使用

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

上述就是一些常用的lamda表达式

lamda表达式中的归约和汇总

reduce

<U> U reduce(U identity,
                 BiFunction<U, ? super T, U> accumulator,
                 BinaryOperator<U> combiner);

可以看见方法中有三个参数，第一个参数 初始化的值 第二个参数 需要计算的方法 第三个参数 如果是并行计算的话会用到，合并第二个参数计算出来的值，这样的解释大家可能不会理解看一下下面的代码就可以了

Order order = list.stream()
                .parallel()
                .reduce(
                        // 初始化值
                        new Order(0, 0, 0.0),

                        // Stream中两个元素的计算逻辑
                        (Order order1, Order order2) -> {
                            System.out.println("执行 计算逻辑 方法！！！");

                            int productCount =
                                    order1.getProductCount()
                                            + order2.getProductCount();

                            double totalAmount =
                                    order1.getTotalAmount()
                                            + order2.getTotalAmount();

                            return new Order(0, productCount, totalAmount);
                        },

                        // 并行情况下，多个并行结果如何合并
                        (Order order1, Order order2) -> {
                            System.out.println("执行 合并 方法！！！");

                            int productCount =
                                    order1.getProductCount()
                                            + order2.getProductCount();

                            double totalAmount =
                                    order1.getTotalAmount()
                                            + order2.getTotalAmount();

                            return new Order(0, productCount, totalAmount);
                        });

第一个参数初始化了一个订单，第二个参数订单的累加，第三个参数合并两个订单

collect

    <R> R collect(Supplier<R> supplier,
                  BiConsumer<R, ? super T> accumulator,
                  BiConsumer<R, R> combiner);

第一个参数返回一个初始值 第二个参数计算的过程 他这个函数式接口没有返回值的 第三个参数并发的合并操作 函数式接口没有返回值


        Map<String, Order> collect = list.stream()
                .parallel()
                .collect(
                        () -> {
                            System.out.println("执行 初始化容器 操作！！！");

                            return new HashMap<String, Order>();
                        },
                        (HashMap<String, Order> map, Order newOrder) -> {
                            System.out.println("执行 新元素添加到容器 操作！！！");

                            /*
                                新元素的account已经在map中存在了
                                不存在
                             */
                            String account = newOrder.getAccount();

                            // 如果此账号已存在，将新订单数据累加上
                            if (map.containsKey(account)) {
                                Order order = map.get(account);
                                order.setProductCount(
                                        newOrder.getProductCount()
                                                + order.getProductCount());
                                order.setTotalAmount(
                                        newOrder.getTotalAmount()
                                                + order.getTotalAmount());
                            } else {
                                // 如果不存在，直接将新订单存入map
                                map.put(account, newOrder);
                            }

                        }, (HashMap<String, Order> map1, HashMap<String, Order> map2) -> {
                            System.out.println("执行 并行结果合并 操作！！！");

                            map2.forEach((key, value) -> {
                                map1.merge(key, value, (order1, order2) -> {

                                    // TODO 注意：一定要用map1做合并，因为最后collect返回的是map1
                                    return new Order(0, key,
                                            order1.getProductCount()
                                                    + order2.getProductCount(),
                                            order1.getTotalAmount()
                                                    + order2.getTotalAmount());
                                });
                            });
                        });

上面介绍了归约和汇总，下面介绍一下java常用的一些收集器

toList

 List<Sku> result = list.stream()
                .filter(sku -> sku.getTotalPrice() > 100)

                .collect(Collectors.toList());

groupingBy

 Map<Object, List<Sku>> group = list.stream()
                .collect(
                        Collectors.groupingBy(
                                sku -> sku.getSkuCategory()));

partitioningBy


        Map<Boolean, List<Sku>> partition = list.stream()
                .collect(Collectors.partitioningBy(
                        sku -> sku.getTotalPrice() > 100));

其他常用的一些方法 在Collectors里面 大家可以自己去看一下

在这里插入图片描述

你算哪块小饼干ys
关注
专栏目录
lambda 流 peek java_JDK8 流与λ表达式
weixin_35953844的博客
03-01 1255
λ表达式什么是λ表达式λ表达式有三部分组成：参数列表，箭头(->)，以及一个表达式或者语句块。public int add(int x, int y) {return x + y;}转换为λ表达式(int x, int y) -> x + y;去除参数类型(x, y) -> x + y;无参 以及 只有一个参数() -> { System.out.println("Hell...
Java8函数式编程Lamda
iwillbeaceo的博客
06-08 1129
简介函数式编程核心：以处理数据的方式处理代码。相比较命令式编程的优点：1. 代码更加简洁优雅，效率更高 2. 避免了对变量的显式修改和赋值 3. 函数式风格的代码可以轻松的实现并行化 4. 代码表达性更强，更直观
7.高级用法
xixihaha_coder的博客
06-01 223
函数式编程lambda表达式
lambda的peek，filter，map，collect函数使用
scofen的博客
04-12 1万+
@RequestMapping(value = "/list.json", method = GET) public void list(ModelMap modelMap, String taskId, Integer currentPage, Integer pageSize) { Pagination pagination = Pagination.builder().curren...
JAVA8新特性学习
qq_33261889的博客
02-01 295
Java8学习
java 8 Stream中操作类型和peek的使用
程序那些事
04-23 1万+
文章目录简介中间操作和终止操作peek结论 java 8 Stream中操作类型和peek的使用 简介 java 8 stream作为流式操作有两种操作类型，中间操作和终止操作。这两种有什么区别呢？ 我们看一个peek的例子： Stream<String> stream = Stream.of("one", "two", "three","four"); stream....
用通俗易懂的大白话搞明白Java里的函数式编程和Lambda表达式
曹举的个人博客
01-22 4967
今天，用通俗易懂的大白话来搞明白Java里的函数式编程和Lambda表达式
C#编程：掌握Lamda表达式在.NET中的实践应用
Lamda表达式是C#编程语言中的一个重要概念，特别是在.NET框架中，它提供了一种简洁的方式来定义匿名方法和表达式。在C# 4.0及更高版本中，Lamda表达式被广泛应用，因为它能简化代码并增强代码的可读性。 在给出的...
Lamda演示代码
09-21
在实际开发中，Lambda表达式不仅提高了代码的简洁性和可读性，还促进了并发编程的简化，因为它们可以很容易地与`java.util.concurrent`包中的并行流结合使用。通过并行化处理，可以充分利用多核处理器的优势，提高...
现代编程语言都具备的Lambda到底是个啥？详细聊聊Lambda与函数式接口
m0_72885838的博客
07-22 1060
本篇主要给大家带来的前世今生和函数式接口的关系，并详细讲解函数式接口中的四个主要接口和一众衍生接口，在文章正式开始之前，想必一些读者也是知道是匿名表达式的，但是可能并不清楚它是根据什么规则进行的转换，想必大家看完本文之后会有一个清晰的了解。...
lambda 流 peek java_jdk10中stream流里面peek方法注意点
weixin_39932181的博客
03-01 874
最近在我的课程里面SpringBoot2.0不容错过的新特性 WebFlux响应式编程里面，有学员提出了以下问题，在jdk10里面代码没有执行(课程中stream流是用jdk8演示的)代码：publicclassLambdaDemo{publicstaticvoidmain(String[]args){IntStream.range(1,10).peek(LambdaDemo::d...
java8 stream接口 终端操作 min，max，findFirst，findAny操作
热门推荐
鸭鸭的博客
06-23 11万+
对于中间操作和终端操作的定义，请看《JAVA8 stream接口 中间操作和终端操作》，这篇主要讲述的是stream的min，max，findFirst，findAny操作，我们先看下函数的定义 Optional<T> min(Comparator<? super T> comparator); Optional<T> max(Compa...
Lambda表达式之并行和并发
xuanzhui1215的专栏
08-16 2093
并行和并发是个非常大的概念，也不是一篇文章能够完全的包含，所以这边只能简要概括如何通过Lambda表达式来实现。   首先并行和并发是两个不同的概念： 并行英文叫Parallelism，理想情况下，每个线程拥有自己独立的cpu核心，像平行线一样的各自执行自己的任务，多用于CPU密集型的任务； 并发英文叫Concurrency，每个线程不一定拥有独立的cpu核心，每次的执行时间点和执行时...
【踩坑总结】java8中stream的findAny踩坑
万事胜意
07-04 3万+
java8中stream的findAny踩坑 需求：寻找list中符合要求的对象 通过findAny去实现 A a = bList().stream().filter(b -> "test".equals(b.getName())).findAny().get(); 结果后面发现这个方法并不是找得到就返回，找不到就不做处理，而是找不到直接抛异常了。 于是后面改用了这种方式 A a =bLi...
JAVA使用Lambda表达式查找list集合中是否包含某值
weixin_43858882的博客
06-13 9182
JAVA使用Lambda表达式查找list集合中是否包含某值 for (String className : allClassName) { if (!classDetailList.stream().filter(o -> ToolUtil.equals(o.getClassName(), className)).findFirst().isPresent()) { classDetailList.add(new AftersaleStatisticDTO().setClassNa
Java Lambda 筛选 filter
03-10 4万+
Java Lambda 筛选 filter public class Menu { /** * 菜品名称 */ private String name; /** * 菜品单价 */ private Double price; /** * 菜品斤数 */ private Double kilo; /** * 菜品类型：蔬菜、水果、肉类 */ private String type; public Menu() { } public Me
Java List Stream的findAny和findFirst的区别
Kube_的博客
05-13 1万+
今天测试了一下Stream.findAny的结果，发现总是返回列表的第一个元素，结果和findFirst一样 搜了一下发现findAny并不是随机地选一个，如果是数据较少，串行地情况下，一般会返回第一个结果，如果是并行的情况，那就不能确保是第一个。 参考：https://stackoverflow.com/questions/35359112/difference-between-...
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 285
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 821
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
lamda
05-24
Lambda是一个匿名函数，它是一种在函数式编程中常见的概念。它可以被用作变量，可以被传递给其他函数作为参数，也可以被其他函数返回。Lambda函数通常是短小精悍的，由于它们没有名称，所以可以在需要时直接使用。 在Python中，Lambda函数的语法很简单，可以写成一个表达式。例如，下面是一个简单的Lambda函数，它将两个参数相加并返回结果： ``` add = lambda x, y: x + y ``` 这个Lambda函数可以像普通函数一样调用： ``` result = add(2, 3) ``` 结果将是5。Lambda函数可以用于许多场景，包括列表排序、过滤器和映射。它们是Python编程中非常有用的工具。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值