Java8 Easy Introduction — 1. Lambda

最新推荐文章于 2023-09-06 15:56:38 发布

_vison_he

最新推荐文章于 2023-09-06 15:56:38 发布

阅读量226

点赞数

分类专栏： Java８文章标签： java lambda

本文链接：https://blog.csdn.net/hws12310/article/details/77132380

版权

Java８专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Java8 Easy Introduction — 1. Lambda

吹水

好吧，其实很早之前就打算开始写些博客，不过一直没有坚持下来。之前打得草稿也不知道到哪里去了，现在心血来潮，来献献丑，求指导指导。

好吧，这里我先废话两句：
1. 本人写博客纯属学习，我就把我的博客当成记记笔记，如果对你刚好有用，那真是感动；
2. 因为个人能力的原因，本人的博客内容可能会比较简单，老鸟勿喷，小鸟勿捧。实事求是，老鸟多指导，小鸟多点赞，谢谢！～～
3. 最后一点：本人写博客的目的除了记笔记以外，还是希望能给新手（好吧，我也是小鸟。。），一些入门的教程吧，所以尽量会写的简单、易懂，老鸟要是觉得没有深度，就Alt + <- 回退吧。

好吧，吹水完毕，开始我们的正式内容吧，Java8中的Lambda表达式。

前言

Java8在2014年由Oracle发布了正式版，其中比较主要的特性就是：Lambda，Stream，Optional以及一些时间处理上的类（LocalData，LocalTime等）。

到现在才来说Java8似乎有点晚了，因为再过不久Java9都要出来了。不过，童鞋们还是不用太着急，因为虽然技术出的很快，但是在生产环境（公司打码）中，更新并不会那么快，因为公司都要求稳，一般不会贸然使用最新的技术。

Java8 Easy Introduction这一个系列的文章，主要是针对有一些Java基础的童鞋，介绍Java8的一些基本特性，对java8有个基本的认识。

本章内容：
- 策略模式
- Lambda表达式和函数接口
- 函数描述符和使用Java自带函数接口
- Lambda简化写法

正式内容

策略模式

好吧，我们首先来讲一些什么是策略模式。

可能有的童鞋会产生疑问，为啥要先讲策略模式？如果心中产生这个疑问，那你就需要继续看下去了。

以下模拟一些数据，创建User类，其中包含：name，gender，age三个属性，以下省略相应的getter，setter方法（好吧，eclipse，在类中右键 -> source -> Genarate getter and setter可以自动生成，我又罗嗦了。）。

以下就是典型JavaBean对象：

public class User {
    public static enum Gender {
        MALE, FEMALE
    }
    private String name;
    private Gender gender;
    private Integer age;
    ....
}

模拟一些数据，包含10个User的List（这里我用了Junit测试来搞）：

public class UserDemoTest {

    private List<User> userList = new ArrayList<>();

    @Before
    public void readyUserData() {
        userList.add(new User("Mike", Gender.MALE, 22));
        userList.add(new User("Bob", Gender.MALE, 22));
        userList.add(new User("Alice", Gender.FEMALE, 22));
        userList.add(new User("Terry", Gender.MALE, 22));
        userList.add(new User("Illies", Gender.FEMALE, 22));
        userList.add(new User("Jesiby", Gender.FEMALE, 22));
        userList.add(new User("Parker", Gender.MALE, 22));
        userList.add(new User("Avril", Gender.FEMALE, 22));
        userList.add(new User("Jerry", Gender.MALE, 22));
        userList.add(new User("Berry", Gender.FEMALE, 22));
    }
}

假设有一个场景：现在有一个List，里面存着10个User对象，老湿叫你筛选出其中所有性别为女的User对象。OK，最直接的解决方案：

@Test
public void screenUserList() {
    List<User> femaleUserList = new ArrayList<>();
    for (int i = 0; i < userList.size(); i++) {
        if (userList.get(i).getGender() == Gender.FEMALE) {
            femaleUserList.add(userList.get(i));
        }
    }
    System.out.println(femaleUserList.size());
}

但是在另外的一个地方，同样是userList，但是要筛选出年龄大于25的用户对象，这个时候，你会怎么办？

再写一次上面的代码，改一下条件？No，No，No，开发软件的原则之一就是：Don’t respeat youself，尽量避免重复代码。

其实仔细分析一下上面的过程，你会发现：代码的框架是不变的，只有判断的逻辑变了。我们可不可以将变化的部分抽取出来？当然可以。这就是策略模式：通过接口告诉方法要做什么操作。

定义一个接口UserClassifyOperation，其中只有一个方法：判断用户是否符合条件

public interface UserClassifyOperation {
    boolean judge(User user);
}

接着，我们创建一个方法，将遍历userList的基本骨架放在方法中，并且传入一个UserClassifyOperation对象（具体判断行为）来影响这个方法的执行结果：

private List<User> classifyUserList(List<User> userList, UserClassifyOperation classifyOperation) {
    List<User> resultUserList = new ArrayList<>();
    for (int i = 0; i < userList.size(); i++) {
        User user = userList.get(i);

        if (classifyOperation.judge(user)) {
            resultUserList.add(user);
        }
    }
    return resultUserList;
}

好吧，你已经把具体的判断行为和常规的遍历行为分离了，接着只需要在调用的时候指定具体的判断逻辑。一般会用匿名内部类去处理，如下：

@Test
public void screenUserList() {
    List<User> resultUserList = classifyUserList(userList, new UserClassifyOperation() {
        @Override
        public boolean judge(User user) {
            return user.getAge() > 25;
        }
    });
    System.out.println(resultUserList.size());
}

现在，你只需要控制方法参数就能控制这个函数的行为了，这就是策略模式。

小小见解：个人觉得传递匿名内部类也是实属无奈，因为Java不能直接传递函数，只能传递对象。就像这种只有一行的代码，就写一段匿名内部类，确实很“不干净”。不过，Java8之后有了Lambda就好多了。

Lambda表达式

什么是Lambda表达式？最直观的理解，就是一个函数。

比如说，举个例子，创建Runnable对象，传统的匿名内部类：

Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("use anonymous inner class");
    }
};

而使用Lambda表达式，则是：

Runnable r = () -> {System.out.println("use lambda");}

是不是Lambda显得简洁许多？这也是为什么函数编程会流行起来的原因：更加抽象，更加简洁。

从上面的例子也可以看出一点：虽然可以使用Lambda表达式，但还是得依附在接口上。

Lambda表达式包含以下三个部分：
1. 参数部分，如：() , (Integer i)；
2. ->，参数部分和方法之间的连接符；
3. { code }，方法块，其中花括号不是必须的，如果指包含一条语句，并且语句的返回值就是方法的返回值，则可以省略花括号。接下来的例子会讲到。

接着讲回之前筛选用户的例子，如何结合策略模式和Lambda？改写之前筛选年龄的例子：

@Test
public void screenUserList() {
    List<User> resultUserList = classifyUserList(userList, (User user) -> user.getAge() > 25);
    System.out.println(resultUserList.size());
}

哇奥！5行变成2行，不得不说，Lambda对于方法代码少的情况，还是比匿名内部类的写法清晰很多。

在上面这种写法，实际上就等于创建了一个对象，传递给方法：

UserClassifyOperation u = (User user) -> user.getAge() > 25 ;

这种写法实际上是和匿名内部类等效的。

那么，明明Lambda表达式更简洁，还要匿名内部类做啥？因为Lambda表达式只能生成函数接口的对象。

那什么又是函数接口呢？其实最直观的理解，只有一个抽象方法的接口。比如之前的UserClassifyOperation接口：

public interface UserClassifyOperation {
    boolean judge(User user);
}

其实从Lambda的用法中，我们也可以看出：你只能指定一个参数列表，一个方法体。如果接口中包含多个方法，那么编译器是不知道你实现的是哪个方法的，所以Lambda只适用于函数接口。

注：在Java中，可以通过@FunctionalInterface来标记函数接口，这样编译器就会帮你做检查，如果超过一个抽象方法，就会抛出一个编译错误。同样，如果在看别人代码时，发现接口有这个注解，那就可以毫不犹豫地使用Lambda表达式了。

函数描述符和Java自带的函数接口

学习了如何使用Lambda表达式之后，我们现在来更进一步的了解一下：编译器是如何判断Lambda表达式编写正确？或者说，编译器是怎么知道Lambda表达式和接口是匹配的？

答案：通过函数描述符来进行判断。

那么什么是函数描述符？最直观的理解就是：参数 + 返回值，就是这个函数接口的函数描述符（函数接口只有一个方法）。

再回到我们刚才的UserClassifyOperation接口，以下对比一下其方法和对应的Lambda表达式：

boolean judge(User user)；   // 方法

(User user) -> user.getAge() > 25 ; //lambda表达式

函数方法接受User类型，并且返回boolean类型的方法，那么User + boolean就是这个函数接口的函数描述符。而我们编写Lambda表达式的时候，也同样会指定参数 + 返回值。这样编译器通过匹配Lambda表达式和函数接口的函数描述符是否一致，就可以判断你的Lambda表达式是否正确。

Lambda作用于多个接口

因为编译器判断Lambda是通过函数描述符来判断，即判断条件只与函数方法参数和返回值相关，和具体的接口，接口方法名无关。那么，假设我还有一个接口UserClassifyOperation2，其中方法也是返回boolean，并且接受User类型的话，同样的Lambda表达式也能作用到这个接口上。

正因为如此，Java已经为我们提供了一些更通用的函数接口，可以直接应用到我们的程序中，以下展示一个Predicate接口。可以到java.util.function中查看更多的函数接口：

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

简单来解释一下：Predicate接口，称为谓词。简单来说，就是判断一个值是否符合条件，其中的test方法就是判断方法。

因为Predicate可以接受泛型，所以我们完全可以用这个接口来替换UserClassifyOperation接口，修改筛选方法：

private List<User> classifyUserList(List<User> userList, Predicate<User> predicate) {
    List<User> resultUserList = new ArrayList<>();
    for (int i = 0; i < userList.size(); i++) {
        User user = userList.get(i);

        if (predicate.test(user)) {
            resultUserList.add(user);
        }
    }
    return resultUserList;
}

同样执行筛选年龄大于25岁的用户的方法：

@Test
public void screenUserList() {
    List<User> resultUserList = classifyUserList(userList, (User user) -> user.getAge() > 25);
    System.out.println(resultUserList.size());
}

可以看到，我们并没有修改Lambda表达式，它可以成功的和UserClassifyOperation以及Predicate接口匹配。再一次说明：同一个Lambda可以作用在多个函数接口上。

Lambda简化写法

先来讲一些Lambda的基本规则：

(User user) -> user.getAge() > 25 ;

上面的式子指定了User参数，返回Boolean类型，下面的式子也是等效的：

(User user) -> {return user.getAge() > 25 ;}

之前讲过这个概念，不加花括号（就是代码块），就默认返回表达式的值；

省略参数类型

虽然将参数类型写出来，有利于编译器帮我们做检查。但是我相信，大多数情况下，你都知道自己在做什么。

所以，其实我们是可以省略参数类型的，如下：

// 单个参数可以省略()
Predicate<User> p = user -> user.getAge() > 25 ; 

// 多个参数必须使用()
Comparator<User> compare = (user1, user2) -> user1.getAge() - user2.getAge();

编译器知道我们要将Lambda表达式匹配到那个接口上，它会自己去推断参数的类型。这样，我们就可以省略参数类型。

使用现有方法引用

假设，你现在已经有一个现成的筛选方法，比如说：

public static boolean isAgeSuite(User user) {
    return user.getAge() > 25;
}

好吧，现在你可以更简化查询的函数了。

@Test
public void screenUserList() {
    List<User> resultUserList = classifyUserList(userList, UserDemoTest::isAgeSuite);
    System.out.println(resultUserList.size());
}

我们通过UserDemoTest::isAgeSuite引用了现有的方法，其实内部过程也不复杂。
1. Predicate接受到一个User类型的参数；
2. 将这个User参数，传递给指定的方法，此处为isAgeSuite；
3. 然后将isAgeSuite的返回值，作为Predicate中函数方法的返回值。

这就是两个最基本的Lambda表达式简化过程了，详细的可以去看《Java８实战》，里面讲得更详细。