java常用的lambda表达式总结

已于 2023-07-28 11:20:45 修改
阅读量727 收藏 1
点赞数 2
文章标签： lambda java
于 2023-07-18 15:19:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010184528/article/details/131779934
版权

目录

一、概述

二、基本格式

三、Stream流

3.1、准备

3.2、常用方法

3.2.1 filter过滤

3.2.2、distinct去重

3.2.3、map映射成一个新的元素

3.2.4、sorted排序+reversed倒序+thenComparing多条件

3.2.5、limit取前几条元素

3.2.6、skip跳过前几条数据

3.2.7、flatMap合并流

3.2.8、count计算数量

3.2.9、max计算最大和min计算最小

3.2.10、collect转换成新集合

3.2.10.1、Collectors.toList() 转list

3.2.10.2、Collectors.toMap() 转map

3.2.10.3、Collectors.toSet() 转set

3.2.10.4、Collectors.groupingBy() 分组

3.2.10.5、Collectors.joining() 转字符串

3.2.11、anyMatch只要有一条数据满足条件即返回true

3.2.12、allMatch必须全部都满足条件才会返回true

3.2.13、noneMatch全都不满足条件才会返回true

3.2.14、findFirst获取第一条数据

3.2.15、reduce根据指定的计算模型计算结果

3.2.16、foreach终结操作

3.2.17、peek中间操作

3.2.18、双列集合

四、Optional

4.1、ofNullable()创建对象可以为null

4.2、ifPresent安全消费

4.3、orElseGet安全获取值

4.4、filter安全过滤

五、函数式接口 

5.1、常用的默认方法

5.1.1、filter方法的Predicate接口

六、函数引用

七、串行流和并行流

一、概述

        lambda表达式是JDK8中的一个新特性，对某些匿名内部类进行简化，是函数式编程；

二、基本格式

        (参数列表)->{方法体代码}

三、Stream流

  • 是jdk8中的新特性，将集合或者数组数据以流的形式进行操作

3.1、准备

@AllArgsConstructor
@NoArgsConstructor
@Data
public class People {
    private int id;
    private String name;
    private int age;
    private String home;
    private List<Friend> friendList;
}
@AllArgsConstructor
@NoArgsConstructor
@Data
public class Friend {
    private int id;
    private String name;
    private int age;
    private String home;
    private String category;//分类
}

 void contextLoads() {
        People people1=new People(1,"曹操",33,"魏国",null);
        People people2=new People(2,"孙权",15,"吴国",null);
        People people3=new People(3,"张飞",14,"蜀国",null);
        People people4=new People(3,"张飞",14,"蜀国",null);
        List<Friend>list1=new ArrayList<>();
        List<Friend>list2=new ArrayList<>();
        List<Friend>list3=new ArrayList<>();
        list1.add(new Friend(1,"刘备",88,"河北，石家庄","好朋友"));
        list1.add(new Friend(2,"赵云",99,"湖北，武汉","新朋友"));

        list2.add(new Friend(3,"周瑜",85,"辽宁，大连","老朋友"));
        list2.add(new Friend(3,"周瑜",85,"辽宁，大连","老朋友"));
        list2.add(new Friend(4,"诸葛亮",56,"内蒙古，包头","大朋友"));

        list3.add(new Friend(5,"郭嘉",56,"甘肃，兰州","骄傲的朋友"));
        list3.add(new Friend(6,"吕布",100,"陕西，西安","厉害的朋友"));
        list3.add(new Friend(7,"吕布",100,"陕西，西安","厉害的朋友"));

        people1.setFriendList(list1);
        people2.setFriendList(list2);
        people3.setFriendList(list3);
        people4.setFriendList(list3);

        List<People>peopleList=new ArrayList<>(Arrays.asList(people1,people2,people3,people4));
    }

3.2、常用方法

3.2.1 filter过滤

//筛选年龄大于15的people
peopleList.stream().filter(new Predicate<People>() {
    @Override
    public boolean test(People people) {
        return people.getAge()>15;
    }
}).forEach(new Consumer<People>() {
    @Override
    public void accept(People people) {
        System.out.println(people);
    }
});
 
----Alt+Enter转为Lambda表达式----
peopleList.stream()
        .filter(people -> people.getAge()>15)
        .forEach(people -> System.out.println(people));

3.2.2、distinct去重

//去除重复数据
peopleList.stream().distinct().forEach(new Consumer<People>() {
    @Override
    public void accept(People people) {
        System.out.println(people);
    }
});
 
----Alt+Enter转为Lambda表达式----
peopleList.stream()
        .distinct()
        .forEach(people -> System.out.println(people));

3.2.3、map映射成一个新的元素

//打印people中的名字，放到List集合中
List<Object> collect = peopleList.stream().map(new Function<People, Object>() {
    @Override
    public Object apply(People people) {
        return people.getName();
    }
}).collect(Collectors.toList());
System.out.println(collect);
 
----Alt+Enter转为Lambda表达式----
List<Object> collect = peopleList.stream()
        .map(people -> people.getName())
        .collect(Collectors.toList());
System.out.println(collect);

3.2.4、sorted排序+reversed倒序+thenComparing多条件

//根据people中的年龄进行升序排序
peopleList.stream()
        .sorted(new Comparator<People>() {
            @Override
            public int compare(People o1, People o2) {
                return o1.getAge()-o2.getAge();
            }
        }).forEach(new Consumer<People>() {
            @Override
            public void accept(People people) {
                System.out.println(people);
            }
        });

********************************

//根据people中的Id和年龄进行倒序排序
peopleList.stream()
        .sorted(Comparator.comparing(new Function<People, Integer>() {
            @Override
            public Integer apply(People people) {
                return people.getId();
            }
        }).thenComparing(new Function<People, Integer>() {
            @Override
            public Integer apply(People people) {
                return people.getAge();
            }
        }).reversed())
        .forEach(people -> System.out.println(people));
 
----Alt+Enter转为Lambda表达式----
peopleList.stream()
        .sorted((o1, o2) -> o1.getAge()-o2.getAge())
        .forEach(people -> System.out.println(people));

********************************

peopleList.stream()        .sorted(Comparator.comparing(People::getId)
                .thenComparing(People::getAge)
                .reversed())
        .forEach(people -> System.out.println(people));

3.2.5、limit取前几条元素

3.2.6、skip跳过前几条数据

//取前3条数据
List<People> list = peopleList.stream().limit(3).collect(Collectors.toList());
System.out.println(list);

3.2.7、flatMap合并流

  • 将流中的每一个元素映射为一个流，再把每一个流连接成为一个流
//获取所有people中每个people的friend的名字
peopleList.stream()
        .flatMap(new Function<People, Stream<Friend>>() {
            @Override
            public Stream<Friend> apply(People people) {
                return people.getFriendList().stream();
            }
        }).forEach(new Consumer<Friend>() {
            @Override
            public void accept(Friend friend) {
                System.out.println(friend.getName());
            }
        });
 
----Alt+Enter转为Lambda表达式----
peopleList.stream()
        .flatMap(people -> people.getFriendList().stream())
        .forEach(friend -> System.out.println(friend.getName()));

3.2.8、count计算数量

//获取所有people中每个people的friend的数量
long num=peopleList.stream().flatMap(people -> people.getFriendList().stream())
        .count();
System.out.println(num);

3.2.9、max计算最大和min计算最小

//获取所有people中的friend的年龄最大的
Optional<People> max = peopleList.stream().max(new Comparator<People>() {
    @Override
    public int compare(People o1, People o2) {
        return o1.getAge() - o2.getAge();
    }
});
System.out.println(max.get());
 
----Alter+Enter转为Lambda表达式----

Optional<People> max = peopleList.stream()
        .max((o1, o2) -> o1.getAge() - o2.getAge());
System.out.println(max.get());

3.2.10、collect转换成新集合

3.2.10.1、Collectors.toList() 转list
3.2.10.2、Collectors.toMap() 转map
3.2.10.3、Collectors.toSet() 转set
3.2.10.4、Collectors.groupingBy() 分组
3.2.10.5、Collectors.joining() 转字符串
//获取所有people中的名字转换为新的集合
List<String>names=peopleList.stream()
        .map(people -> people.getName())
        .collect(Collectors.toList());
System.out.println(names);

//获取所有people中的friend集合转set
Set<Friend>set=peopleList.stream()
        .flatMap(people -> people.getFriendList().stream())
        .collect(Collectors.toSet());
System.out.println(set);

//以people集合中的名字为键，friend集合为值，转map
Map<String,List<Friend>>map=peopleList.stream().distinct()
        .collect(Collectors.toMap(people -> people.getName(), people -> people.getFriendList()));
System.out.println(map);
//groupingBy分组
Map<String, List<People>> collect = peopleList.stream()
        .collect(Collectors.groupingBy(people -> people.getName()));
System.out.println(collect);

//joinging拼接成字符串
String names = peopleList.stream()
        .map(people -> people.getName()).collect(Collectors.joining("，"));
System.out.println(names);

3.2.11、anyMatch只要有一条数据满足条件即返回true

3.2.12、allMatch必须全部都满足条件才会返回true

3.2.13、noneMatch全都不满足条件才会返回true

//以people集合中是否有年龄大于15岁的，有一个结果就为true
boolean ishave=peopleList.stream().anyMatch(new Predicate<People>() {
    @Override
    public boolean test(People people) {
        return people.getAge()>15;
    }
});
 
----Alter+Enter转为Lambda表达式----

boolean ishave=peopleList.stream().anyMatch(people -> people.getAge()>15);

3.2.14、findFirst获取第一条数据

//获取people中年龄最小的第一条数据
Optional<People> first = peopleList
        .stream()
        .distinct()
        .sorted((o1, o2) -> o1.getAge() - o2.getAge())
        .findFirst();
first.ifPresent(people -> System.out.println(people));

3.2.15、reduce根据指定的计算模型计算结果

//计算people中每个人的年龄的总和
Integer result=peopleList.stream()
        .map(new Function<People, Integer>() {
            @Override
            public Integer apply(People people) {
                return people.getAge();
            }
        }).reduce(0,new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) {
                System.out.println("integer="+integer+"  integer2="+integer2+"  integer+integer2="+(integer+integer2));
                return integer+integer2;
            }
        });
----Alter+Enter转为Lambda表达式----

Integer result=peopleList.stream()
        .map(people -> people.getAge())
        .reduce(0, (integer, integer2) -> {
            System.out.println("integer="+integer+"  integer2="+integer2+"  integer+integer2="+(integer+integer2));
            return integer+integer2;
        });

带初始值的循环计算，第一个integer是每次计算的结果，第二个integer2是每次输入进来的值

//计算people中最小的年龄
Optional<Integer> reduce = peopleList.stream().distinct()
        .map(new Function<People, Integer>() {
            @Override
            public Integer apply(People people) {
                return people.getAge();
            }
        }).reduce(new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) {
                return integer<integer2?integer:integer2;
            }
        });

----Alter+Enter转为Lambda表达式----

Optional<Integer> reduce = peopleList.stream().distinct()
        .map(people -> people.getAge())
        .reduce((integer, integer2) -> integer<integer2?integer:integer2);

3.2.16、foreach终结操作

  • 循环遍历

3.2.17、peek中间操作

  • 需要联合终结操作才会执行
  • 一般用于debug调试联合使用
  • 不会改变流的属性
//不会执行
peopleList.stream()
        .peek(people -> System.out.println(people.getName()));

//会执行
List<People> collect = peopleList.stream()
        .peek(people -> System.out.println(people.getName()))
        .collect(Collectors.toList());
System.out.println(collect);

3.2.18、双列集合

Map<String,Integer>map=new HashMap<>();
map.put("aaa",1);
map.put("bbb",2);
map.put("ccc",3);
map.put("ddd",4);
Set<Map.Entry<String, Integer>> entries = map.entrySet();
entries.stream().forEach(new Consumer<Map.Entry<String, Integer>>() {
    @Override
    public void accept(Map.Entry<String, Integer> stringIntegerEntry) {
        System.out.println(stringIntegerEntry);
    }
});

entries.stream().forEach(stringIntegerEntry -> System.out.println(stringIntegerEntry));

四、Optional

  • 避免出现空而创建的

4.1、ofNullable()创建对象可以为null

//创建对象
Optional<People> optional = Optional.ofNullable(people);

4.2、ifPresent安全消费

  • 如果对象为空，就不消费，不为空就消费
//people为空
People people=null;
Optional<People> optional = Optional.ofNullable(people);
optional.ifPresent(new Consumer<People>() {
    @Override
    public void accept(People people) {
        System.out.println(people);
    }
});
//people不为空
People people22=peopleList.get(0);
Optional<People> optional2 = Optional.ofNullable(people22);
optional2.ifPresent(new Consumer<People>() {
    @Override
    public void accept(People people) {
        System.out.println(people);
    }
});
 
//people为空
People people=null;
Optional<People> optional = Optional.ofNullable(people);
optional.ifPresent(people5 -> System.out.println(people5));
//people不为空
People people22=peopleList.get(0);
Optional<People> optional2 = Optional.ofNullable(people22);
optional2.ifPresent(people52 -> System.out.println(people52));

4.3、orElseGet安全获取值

  • 对象为空不获取，不执行
//people为空
People peopleNull=null;
Optional<People> optional = Optional.ofNullable(peopleNull);
People p = optional.orElseGet(new Supplier<People>() {
    @Override
    public People get() {
        return null;
    }
});
System.out.println(p);

//people不为空
People peopleNotNull=peopleList.get(0);
Optional<People> optionalNotNull = Optional.ofNullable(peopleNotNull);
People pp =optionalNotNull.orElseGet(new Supplier<People>() {
    @Override
    public People get() {
        return null;
    }
});
System.out.println(pp);
 
//people为空
People peopleNull=null;
Optional<People> optional = Optional.ofNullable(peopleNull);
People p = optional.orElseGet(() -> null);
System.out.println(p);

//people不为空
People peopleNotNull=peopleList.get(0);
Optional<People> optionalNotNull = Optional.ofNullable(peopleNotNull);
People pp =optionalNotNull.orElseGet(() -> null);
System.out.println(pp);

4.4、filter安全过滤

  • 对象为空不消费，不执行
//people为空
People peopleNull=null;
Optional<People> optional = Optional.ofNullable(peopleNull);
optional.filter(new Predicate<People>() {
    @Override
    public boolean test(People people) {
        return people.getAge() > 14;
    }
}).ifPresent(new Consumer<People>() {
    @Override
    public void accept(People people) {
        System.out.println(people.getName());
    }
});
 
People peopleNull=null;
Optional<People> optional = Optional.ofNullable(peopleNull);
optional.filter(people -> people.getAge() > 14)
        .ifPresent(people -> System.out.println(people.getName()));

五、函数式接口 

  • 只有一个抽象方法的接口，但是也可以有其他的方法(默认、静态、私有)
  • 一般都加上了@FunctionalInterface注解进行标识，但是也有的函数式接口没有该注解

5.1、常用的默认方法

5.1.1、filter方法的Predicate接口

  • 进行条件拼接（and 和 or 和其他等）
//获取people中年龄大于14且名字长度大于2
peopleList.stream().filter(new Predicate<People>() {
    @Override
    public boolean test(People people) {
        return people.getAge()>14;
    }
}.and(new Predicate<People>() {
    @Override
    public boolean test(People people) {
        return people.getName().length()>2;
    }
})).forEach(new Consumer<People>() {
    @Override
    public void accept(People people) {
        System.out.println(people);
    }
});
 
----Alter+Enter转Lambda表达式----

peopleList.stream()
        .filter(((Predicate<People>) people -> people.getAge() > 14)
                .and(people -> people.getName().length()>2))
        .forEach(people -> System.out.println(people));

或者不要and，用&&写一起，可读性会更好

peopleList.stream()
        .filter(people -> people.getAge()>14 && people.getName().length()>2)
        .forEach(people -> System.out.println(people));

六、函数引用

Alter+enter

转换的结果就是将内部类转换成lambda或者refrence写法

//获取people中年龄大于14且名字长度大于2
peopleList.stream()
        .sorted(Comparator.comparing((Function<People, Integer>) people -> people.getId())
                .thenComparing(people -> people.getAge()).reversed())
        .forEach(people -> System.out.println(people));
peopleList.stream()
        .sorted(Comparator.comparing(People::getId)
                .thenComparing(People::getAge).reversed())
        .forEach(people -> System.out.println(people));

七、串行流和并行流

  • 并行流是多线程，串行流是单线程，如果数据量比较大，用并行流
peopleList.stream()创建串行流

peopleList.stream().parallel()串行流转成并行

peopleList.parallelStream()直接创建并行流

        

                        

小小苏的小小苏
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
Java基础——Lambda表达式
weixin_61275790的博客
04-06 537
(匿名内部类被重写方法的形参列表) -> {new 类|抽象类名|或者接口名() {被重写方法的方法体代码。注：-> 是语法形式，无实际含义。
从初学者到专家：Java的Lambda表达式完整指南
最新发布
LHY537200的博客
03-21 9638
Lambda是Java中的一种函数式编程特性，它允许以简洁、灵活的方式定义行为（函数），并将其作为参数传递给方法或操作集合数据。通过Lambda表达式，我们可以更方便地实现函数式编程的思想，简化代码编写，并提高代码的可读性和可维护性。它是Java语言在处理函数对象和函数式编程方面的重要进步，为开发者提供了更多的编程选择和表达能力。
JAVA8，常用Lambda总结。
Crazy_Cw的博客
12-28 3203
`Java 8`的`Lambda`表达式
Java中使用Lambda表达式和filter方法对List集合进行过滤
JavaWebEngineer的博客
07-17 9631
一、代码测试案例 package demo; import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; import entity.User; public class Test01 { public static void main(String[] args) { // 创建集合对象 List<User> list = new ArrayList<&
Java 常用lambda操作集合
ljz2016的博客
11-02 926
lambda
java lambda表达式用法总结
08-25
Java Lambda 表达式用法总结 Java Lambda 表达式是 Java 8 中引入的一种新的编程方式，它允许开发者使用简洁的语法来表示单方法接口的实现。下面是 Java Lambda 表达式的详细用法总结： 一、什么是函数式编程？ ...
java8 lambda表达式学习总结
04-23
1. **类型推断**：Java 8 可以自动推断Lambda表达式的参数类型，因此在许多情况下，我们无需显式声明类型。 2. **捕获外部变量**：Lambda 表达式可以访问和修改其定义范围内的 final 或基本类型的局部变量。 3. **...
Java8新特性Lambda表达式的一些复杂用法总结
08-29
Java 8引入了Lambda表达式，这是一种强大的新特性，它为Java编程语言带来了函数式编程的概念。Lambda表达式允许程序员创建匿名函数，即没有名称的函数，这些函数可以直接作为值传递给方法或存储在变量中。这使得代码...
java8之lambda表达式用法总结
08-25
Java8之lambda表达式用法总结 lambda 表达式是 Java8 中的一种新的语法特性，它允许开发者以简洁的方式表示可传递的匿名函数。Lambda 表达式的基本语法是 `(parameters) -> expression` 或 `(parameters) -> { ...
Lambda表达式和Java集合框架
08-31
Lambda表达式和Java集合框架 Lambda表达式和Java集合框架是Java8中两个重要的概念，本文主要介绍了这两个概念的相关知识，并对Java集合框架中新增的方法进行了详细的讲解。下面是相关知识点的总结： 一、Lambda...
Java中lambda表达式的使用
Mylvzi的博客
12-07 962
💕"我不要麻木的死去"💕作者：Mylvzi文章主要内容：Java中lambda表达式的使用。
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 lambda表达式对List进行操作，包括过滤、指定字段去重、合计、分组统计、排序、列表转字符串
gdgztt的专栏
03-02 3701
java lambda表达式对list进行操作，包括过滤、指定字段去重、合计、分组统计、排序、列表转字符串，熟练使用将告别xml写复杂sql
lamda过滤_java 使用Lambda和filter对对象集合过滤
weixin_39630126的博客
12-21 1034
1、如下：用户对象public class User(){private String name;private int age;private String sex;}2、构造用户集合List list = new ArrayList<>();User user1 = new User("张三",15,"男");User user2 = new User("李四",22,"男");U...
Java8 Stream Lambda sorted()之正序倒序
红袖添香的博客
06-02 3780
下面代码以自然序排序一个list list.stream().sorted()
Java小知识：使用Lambda函数，根据一个字段对List集合进行排序（升序&倒序）
危险、的博客
04-26 4010
1.升序排列 public static void main(String[] args){ List<SpClassConfig> spClassConfigs = new ArrayList<SpClassConfig>(); SpClassConfig spClassConfig = new SpClassConfig(); spClassConfig.setClassId("1"); spClassConfig.setClassDays(50); spClassCo
java集合过滤出符合条件的List元素集合（lambda表达式）
angleofdeath9的博客
08-03 9560
在项目开发的过程中，我们经常会对List集合进行按条件的过滤，筛选出我们想要的结果或者是符合项目需求的数据。比如：我们有一批学生对象，每个学生都有自己的性别属性，但是我们想要再班级实体中筛选出这一批学生中性别为男或女的学生，我们就需要对这一批学生集合中的数据进行按条件的筛选，得到我们想要的结果。（多表连接:双向映射）......
java8新特性——Lambda 表达式总结
qiukuqiuku的博客
05-01 1023
Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的Java 代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。
java8 lambda使用汇总
10-29 2803
从java8出现以来lambda是最重要的特性之一，它可以让我们用简洁流畅的代码完成一个功能。 很长一段时间java被吐槽是冗余和缺乏函数式编程能力的语言，随着函数式编程的流行java8种也引入了 这种编程风格。在此之前我们都在写匿名内部类干这些事，但有时候这不是好的做法，本文中将介绍和使用lambda， 带你体验函数式编程的魔力。 lambda表达式语法结构： 在lambda表达式中，通过如下...
java8 lambda表达式
09-13
Java 8引入了Lambda表达式作为这个版本的一个重要特性。...总结来说，Java 8的Lambda表达式是一种用于实现接口中抽象方法的匿名函数，通过简洁的语法和灵活的使用方式，可以使代码更加简洁和可读性更高。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小小苏的小小苏

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值