通俗易懂的Lambda表达式

一）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()));

 

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

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