通俗易懂的Lambda表达式

本文介绍了Lambda表达式的基本概念,包括其语法格式、特点和优势。Lambda表达式是Java8的一个重要特性,用于创建匿名函数,简化代码。文中通过自定义Lambda表达式的例子,解释了如何将函数赋值给变量,并探讨了原生态Lambda表达式在处理数据流时的应用,如filter、map、distinct等方法的使用。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

一)Lambda表达式简介

Lambda表达式是一个匿名函数,也可以称为闭包,是Java8中一个新特性。

 

Lambda表达式语法格式

(parameters) -> expression;

(parameters) -> { statements; }

 

Lambda表达式特征

1)可选类型声明:不需要声明参数类型,编译器可以统一识别参数值类型。 

2)可选的参数圆括号:一个参数无需定义圆括号,但多个参数需要定义圆括号。 

3)可选的大括号:如果主体只包含了一个语句,可省略大括号。

4)可选的返回关键字:如果主体只有一个表达式返回值,则编译器会自动返回值,否则大括号中需要指定表达式返回值。

 

Lamdba优点

1)代码简洁。​

2)容易学习和使用​,可快速开发。

3)维护方便,比如当jdk对Lambda进行升级优化或调整时,不需要修改代码。

 

@FunctionalInterface:函数式接口,有以下几个特点。

1)接口中有且仅有一个抽象方法

2)可允许定义静态方法默认方法

3)允许java.lang.Object中的public方法。

4)该注解不是必须的,只要符合“函数式接口”即可,加上该注解能让编译器更好检查。如不符合规则,又添加该注解,编译器就会报错。

 

二)自定义Lambda表达式

在Java中,每一个方法可以看作一个函数,那怎么把一个函数赋值给一个变量,如下图。

如果直接用“=”号方式赋值肯定会报错,可以把一些方法类型去除,如下图:

把一些方面修饰符和参数去除,如下图:

Lambda表达式处理好,但printFunction参数的类型还需要处理一下,printFunction参数类型需要声明成函数式接口。

如果有返回值的话,把函数接口中方法修改一下,然后在Lambda表达式中大括号尾部添加返回值代码。

 

自定义Lambdm表达式案例

public class LambdaTest {
    // 计算函数
    interface Calculate {
        int operate(int a, int b);
    }

    // 函数参数
    public int operate(int a, int b, Calculate calc) {
        return calc.operate(a, b);
    }

    public static void main(String[] args) {
        LambdaTest lambdaTest = new LambdaTest();

        // 有参数类型
        Calculate add = (int a, int b) -> a + b;
        System.out.println("30 + 5 = " + lambdaTest.operate(30, 5, add));

        // 无参数类型
        Calculate subtract = (a, b) -> a - b;
        System.out.println("30 - 5 = " + lambdaTest.operate(30, 5, subtract));

        // 有参数类型并且有返回值
        Calculate multiply = (int a, int b) -> { return a * b; };
        System.out.println("30 x 5 = " + lambdaTest.operate(30, 5, multiply));

        // 无大括号和返回值
        Calculate div = (int a, int b) -> a / b;
        System.out.println("30 / 5 = " + lambdaTest.operate(30, 5, div));
    }
}

 

三)原生态Lambda表达式

第一步:自定义一个JavaBean

public class User {
    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    
    private String name; // 姓名
    private Integer age; // 年龄
    public void setAge(Integer age) {
        this.age = age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public String getName() {
        return name;
    }
}

 

第二步:定义一个函数式接口,该函数判断是否符合条件,再定义一个静态方法处理数据。

@FunctionalInterface
public interface CheckUser {
    boolean check(User user);
}
public static List<User> checkAndAddUser(List<User> userList,
                                       CheckUser checkUser) {
    List<User> list = new ArrayList<User>();
    for (User user : userList) {
        if (checkUser.check(user)) {
            System.out.println("name: " + user.getName() + ", age: " +user.getAge());
            list.add(user);
        }
    }
    return list;
}

 

第三步:初始化一些用户数据,并添加一个main方法测试

public static void main(String[] agrs) {
    List<User> userList = Arrays.asList(
        new User("ouyangjun", 27),
        new User("oysept", 17),
        new User("zhangsanfeng", 107),
        new User("yewen", 37),
        new User("zhangzhang", 7)
    );

    // 函数式接口测试
    List<User> list = checkAndAddUser(userList,
            u -> u.getName().startsWith("zhang")); // 以zhang开头的用户数据
}

 

第四步:对函数式接口进行优化

List<User> list = userList.stream().filter(u -> u.getName().startsWith("zhang")).collect(Collectors.toList());
list.forEach(user -> System.out.println("name: " + user.getName() + ", age: " +user.getAge()));

把foreach转换成stream(),把过滤添加转换成filter,最后再打印到控制台。

 

原生态Lambdm表达式案例(java.util.Stream)

1):boolean allMatch(Predicate<? super T> predicate):返回此流的所有元素是否与提供的谓词匹配。

// 匹配所有用户是否都是以“zhang”开头
boolean allMatch = userList.stream().allMatch(u->u.getName().startsWith("zhang"));
System.out.println(allMatch); // false

 

2)boolean anyMatch(Predicate<? super T> predicate):返回此流的任何元素是否与提供的谓词匹配。

// 匹配姓名以“zhang”开头并且年龄>100的用户
Predicate<User> p1 = u -> u.getName().startsWith("zhang");
Predicate<User> p2 = u -> u.getAge() > 100;
        
boolean anyMatch = userList.stream().anyMatch(p1.and(p2));
System.out.println(anyMatch); // true

 

3)Stream<T> filter(Predicate<? super T> predicate):返回由与此给定谓词匹配的此流的元素组成的流。

// 匹配姓名以“zhang”开头并且年龄>100的用户
List<User> filterList = userList.stream()
    .filter(u -> u.getName().startsWith("zhang"))
    .filter(u -> u.getAge() > 100)
    .collect(Collectors.toList()); // 把Stream转换成List

 

4)long count():返回此流中的元素数。

// 返回数量
long count = userList.stream().count();
System.out.println(count);

 

5)Stream<T> distinct():返回由该流的不同元素(根据 Object.equals(Object) )组成的流。

// 对数据去重并打印
List<String> strList = Arrays.asList("AA", "BB", "AA", "CC");
strList.stream().distinct().forEach(s -> System.out.println(s)); // AA BB CC
        
// distinct只能通过equals的方式去重, 所以先把姓名转换成map string, 再对数据去重
// 如果不自己转换, 就需要自己重写User类的equals方法
List<String> distinctList = userList.stream().map(u->u.getName()).distinct().collect(Collectors.toList());

 

6)void forEach(Consumer<? super T> action):对此流的每个元素执行操作。

userList.forEach(u -> System.out.println("name: " + u.getName() + ", age: " + u.getAge()));

 

7)<R> Stream<R> map(Function<? super T,? extends R> mapper):返回由给定函数应用于此流的元素的结果组成的流。

List<String> mapList = userList.stream().map(u->u.getName()).collect(Collectors.toList());
mapList.forEach(s -> System.out.println(s));

// 函数
Function<Integer, Integer> name = e -> e * 2;
Function<Integer, Integer> square = e -> e * e;
System.out.println(name.andThen(square).apply(3)); // 36
        
Function<User, String> funName = n -> n.getName();
List<String> functionList = userList.stream().map(funName).collect(Collectors.toList());
functionList.forEach(s -> System.out.println(s));

 

8)Stream<T> limit(long maxSize):返回由此流的元素组成的流,截短长度不能超过 maxSize。

// 获取前几条数据
List<User> limitList = userList.stream().limit(3).collect(Collectors.toList());
limitList.forEach(u -> System.out.println("name: " + u.getName() + ", age: " + u.getAge()));

 

9)Stream<T> skip(long n):在丢弃流的第一个 n元素后,返回由该流的 n元素组成的流。

// 丢去前几条数据
List<User> skipList = userList.stream().skip(3).collect(Collectors.toList());
skipList.forEach(u -> System.out.println("name: " + u.getName() + ", age: " + u.getAge()));

 

10)Stream<T> sorted():返回由此流的元素组成的流,根据自然顺序排序。

List<Integer> nums = Arrays.asList(7, 4, 6, 9, 3, 5);
List<Integer> numsList = nums.stream().sorted().collect(Collectors.toList());
numsList.forEach(n -> System.out.println(n));

 

11)Stream<T> sorted(Comparator<? super T> comparator):返回由该流的元素组成的流,根据提供的 Comparator进行排序。

// 逆序排序, 去掉reversed()就是正序排序
Function<User, Integer> funAge = n -> n.getAge();
List<User> sortedList = userList.stream().sorted(Comparator.comparing(funAge).reversed()).collect(Collectors.toList());
sortedList.forEach(u -> System.out.println("name: " + u.getName() + ", age: " + u.getAge()));
        
// 对象方式排序, User::getName表示User类中getName的方法名
List<User> objList = userList.stream().sorted(Comparator.comparing(User::getName).reversed()).collect(Collectors.toList());
objList.forEach(u -> System.out.println("name: " + u.getName() + ", age: " + u.getAge()));

 

识别二维码关注个人微信公众号

本章完结,待续,欢迎转载!
 
本文说明:该文章属于原创,如需转载,请标明文章转载来源!

Lambda表达式在处理集合元素时,有可能会遇到空指针异常(NullPointerException)的问题。当对一个集合进行stream操作时,如果集合中的元素存在空值,那么在Lambda表达式中使用该元素的属性或方法时就会抛出空指针异常。 在你提供的代码中,当使用Lambda表达式中的`o.getId()`时,如果`o`的`id`属性为空,会抛出空指针异常。正常情况下,`list`不为空,最多会抛出`NumberFormatException`,但在这里抛出的却是空指针异常。 要解决这个问题,你可以在Lambda表达式中添加空值判断。例如,可以使用`Optional`类来对`o.getId()`进行空值检测,避免抛出空指针异常。可以使用类似下面的代码来处理: ``` list.stream() .map(o -> Optional.ofNullable(o.getId()).map(Long::valueOf).orElse(null)) .collect(Collectors.toList()); ``` 通过使用`Optional.ofNullable`方法来包装`o.getId()`,如果`o.getId()`为空,就返回`null`,否则将其转换为`Long`类型。这样做可以避免空指针异常的发生,让代码更加健壮。 引用: - lambda表达式中list.stream().map(o -> Long.valueOf(o.getId())).collect(Collectors.toList());报出了NPE,正常情况下list不为空不会发生NPE,最多o.getId()中id为空Long.valueOf(null)为空抛出NumberFormatException,但是最终却是因为id为空抛出了NPE。 - 此时为空指针异常NPE,而不是NumberFormatException - 本教程为授权出品教程 本套视频涵盖了 Java8 的新特性:Lambda表达式、强大的 Stream API、全新时间日期 API、...Java8 的新特性使 Java 的运行速度更快、代码更少(Lambda 表达式)、便于并行、最大化减少空指针异常。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* [lambda表达式中奇怪的NullPointerException异常](https://blog.youkuaiyun.com/loveyour_1314/article/details/121668039)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *3* [通俗易懂的Java8新特性教程(含配套资料)](https://download.youkuaiyun.com/download/weixin_26875051/19651829)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值