深入探寻JAVA8 part1:函数式编程与Lambda表达式

Java基础

浏览数:65

2019-10-14

AD:资源代下载服务

开篇

在很久之前粗略的看了一遍《Java8 实战》。客观的来,说这是一本写的非常好的书,它由浅入深的讲解了JAVA8的新特性以及这些新特性所解决的问题。最近重新拾起这本书并且对书中的内容进行深入的挖掘和沉淀。接下来的一段时间将会结合这本书,以及我自己阅读JDK8源码的心路历程,来深入的分析JAVA8是如何支持这么多新的特性的,以及这些特性是如何让Java8成为JAVA历史上一个具有里程碑性质的版本。

Java8的新特性概览

在这个系列博客的开篇,结合Java8实战中的内容,先简单列举一下JAVA8中比较重要的几个新特性:

  1. 函数式编程与Lambda表达式
  2. Stram流处理
  3. Optional解决空指针噩梦
  4. 异步问题解决方案CompletableFuture
  5. 颠覆Date的时间解决方案

后面将针对每个专题发博进行详细的说明。

简单说一说函数式编程

函数式编程的概念并非这两年才涌现出来,这篇文章用一种通俗易懂的方式对函数式编程的理念进行讲解。顾名思义,函数式编程的核心是函数。函数在编程语言中的映射为方法,函数中的参数被映射为传入方法的参数,函数的返回结果被映射为方法的返回值。但是函数式编程的思想中,对函数的定义更加严苛,比如参数只能被赋值一次,即参数必须为final类型,在整个函数的声明周期中不能对参数进行修改。这个思想在如今看来是不可理喻的,因为这意味着任何参数的状态都不能发生变更。

那么函数式编程是如何解决状态变更的问题呢?它是通过函数来实现的。下面给了一个例子:

String reverse(String arg) {
    if(arg.length == 0) {
        return arg;
    }
    else {
        return reverse(arg.substring(1, arg.length)) + arg.substring(0, 1);
    }
}

对字符串arg进行倒置并不会修改arg本身,而是会返回一个全新的值。它完全符合函数式编程的思想,因为在整个函数的生命周期中,函数中的每一个变量都没有发生修改。这种不变行在如今称为Immutable思想,它极大的减少了函数的副作用。这一特性使得它对单元测试,调试以及编发编程极度友好。因此在面向对象思想已经成为共识的时代,被重新提上历史的舞台。

但是,编程式思想并不只是局限于此,它强调的不是将所有的变量声明为final,而是将这种可重入的代码块在整个程序中自由的传递和复用。JAVA中是通过对象的传递来实现的。举个例子,假如现在有一个筛选订单的功能,需要对订单从不同的维度进行筛选,比如选出所有已经支付完成的订单,或是选出所有实付金额大于100的订单。

简化的订单模型如下所示:

public class Order{

    private String orderId;

    //实付金额
    private long actualFee;
    
    //订单创建时间    
    private Date createTime;
    
    private boolean isPaid
}

接着写两段过滤逻辑分别实现选出已经支付完成的订单,和所有实付金额大于100的订单

//选出已经支付完成的订单
public List<Order> filterPaidOrder(List<Order> orders) {
    List<Order> paidOrders = new ArrayList<>();
    for(Order order : orders) {
        if(order.isPaid()) {
            paidOrders.add(order);
        }
    }
    return paidOrdres;
}

//选出实付金额大于100的订单
public List<Order> filterByFee(List<Order> orders) {
    List<Order> resultOrders = new ArrayList<>();
    for(Order order : orders) {
        if(order.getActualFee()>100) {
            resultOrders.add(order);
        }
    }
    return resultOrders;
}

可以看到,上面出现了大量的重复代码,明显的违背了DRY(Dont Repeat Yourself)原则,可以先通过模板模式将判断逻辑用抽象方法的形式抽取出来,交给具体的子类来实现。代码如下:

public abstract class OrderFilter{
    
    public List<Order> filter(List<Order> orders) {
        List<Order> resultOrders = new ArrayList<>();
        for(Order order : orders) {
            //调用抽象方法
            if(isWantedOrder(order)) {
                resultOrders.add(order);
            }
        }
        return resultOrders;
    }
    abstract boolean isWantedOrder(Order o);
}

public abstract class PaidOrderFilter extends OrderFilter{
    //重写过滤的判断逻辑
    boolean isWantedOrder(Order o){
        return o.isPaid();
    }
}

public abstract class FeeOrderFilter extends OrderFilter{
    //重写过滤的判断逻辑
    boolean isWantedOrder(Order o){
        return o.getActualFee() > 100;
    }
}

但是,继承本身会带来类和类之间比较重的耦合,而可重入函数的传递则解决了这个问题。代码如下:

public interface OrderFilter{
    boolean isWantedOrder(Order o);
}

public List<Order> filter(List<Order> orders, OrderFilter orderFilter) {
    List<Order> resultOrders = new ArrayList<>();
    for(Order order : orders) {
        if(orderFilter.isWantedOrder(o)) {
            resultOrders.add(order);
        }
    }
    return resultOrders;
}

//过滤出已经支付的订单
filter(orders, new OrderFilter(){
    @Override
    public boolean isWantedOrder(Order o){
        return o.isPaid();
    }
})

通过这种方式,filter方法基本上处于稳定,只需要自定义传入的订单过滤器即可。但是,在当代对可读性和减少重复代码的极致追求下,重构到这种程度依然不能让具有代码洁癖的程序员们满意,于是Lambda表达式应运而生。

Lambda表达式

Java8中的Lambda表达式和Lambda Calculus并不是一个概念,因此所有被Lambda计算伤害过的小伙伴千万不要恐惧。在Java8中,它更加类似于匿名类的代码糖,从而极大的提高代码的可读性(大部分场景),灵活性和简洁性。Lambda表达式的基本结构如下:

(parameters) -> expression
(parameters) -> {expression}

它其实就是函数的一个简化版本,括号中的parameters会填入这个函数的参数类型,在expression中会填入具体执行的语句。如果没有大括号,则expression只允许填入一条语句,且会根据Lambda表达是的上下文,自动补全return语句。举几个具体的例子:

() -> "hello world" 类似于 String methodName(){return "hello world";}
(int i, int j) -> i > j 类似于 Boolean compare(){ return i > j; } 

因此Lambda表达式本质上就是对匿名函数的一种快捷展示。而上面的代码使用lambda表达式还可以继续重构如下:

//标记该接口为函数式接口,要求只能有一个待实现的函数声明
@FuncationalInterface
public interface OrderFilter{
    boolean isWantedOrder(Order o);
}

public List<Order> filter(List<Order> orders, OrderFilter orderFilter) {
    List<Order> resultOrders = new ArrayList<>();
    for(Order order : orders) {
        if(orderFilter.isWantedOrder(o)) {
            resultOrders.add(order);
        }
    }
    return resultOrders;
}

//过滤出已经支付的订单
filter(orders, (Order o) -> o.isPaid());
filter(orders, (Order o) -> o.getActualFee() > 100);

Lambda表达式本身还有一些约定,以及进一步简化的空间,这点各位笔者可以通过这篇文章自行再去了解。

Lambda的灵活性还体现在同样的Lambda表达式可以赋值给不同的函数式接口,代码如下:

@FuncationalInterface
public interface Runnable{
    void run();
}

@FuncationalInterface
public interface AnotherInterface{
    void doSomething();
}

Runnable r = () -> System.out.println("hello world");
AnotherInterface a = () -> System.out.println("hello world");

那么编译器是如何解析Lambda表达式的呢?它其实是根据上下文推断该Lambda表达式该映射到什么函数式接口上的。就以上文的filter方法为例子,它传入的函数式接口为OrderFilter,其中函数的定义为传入Order并返回Boolean值。编译器就会根据这个上下文来判断Lambda表达式是否符合函数式接口的要求,如果符合,则将其映射到该函数式接口上。

Lambda表达式中的局部变量和异常

Lambda表达式作为匿名类的语法糖,它的特性和匿名类保持一致。即如果Lambda表达式要抛出一个非检查性异常(Unchecked Error), 则需要在函数式接口中显示的声明出来。如下:

@FuncationalInterface
public interface AnotherInterface{
    void doSomething() throws UncheckedException;
}

除此以外,还有一个场景是需要在Lambda表达式中引用外部的变量。外部的变量包括局部变量,实例变量和静态变量。其中,只允许对实例变量和静态变量进行修改,所有的被引用的局部变量都必须显性的或是隐形的声明为final。代码如下:

//实例变量
int fieldVariable;

public void someMethod() {
    //局部变量
    int localVariable = 0;
    
    //不允许修改局部变量
    Runnable r1 = () -> localVariable++;
    
    //可以修改实例变量
    Runnable r2 = () -> fieldVarialbe++;
    
    //不允许,因为被Lambda表达式引用的局部变量必须显式或隐式的声明为局部变量
    Runnable r3 = () -> System.out.println(localVariable);
    localVariable++;
}

之所以有这样的约定,是因为局部变量是保存于栈上的,保存于栈上意味着一旦该方法执行完毕,栈中的局部变量就会被弹出并回收。这里也隐式的表明局部变量其实是约束于当前线程使用的。此时如果Lambda表达式是传递到其它线程中执行的,比如上文中创建的Runnable对象传递给线程池执行,则会出现访问的局部变量已经被回收的异常场景。而实例变量和静态变量则不同,二者是保存在堆中的,本身就具有多线程共享的特性

方法的引用

方法的引用证明程序员对代码的洁癖已经到了无法抢救的程度。JAVA8中提出的方法引用的思想允许我们将方法定义传递给各个函数。比如如果要使用System.out.print方法,则可以传入System.out::println。方法的引用主要有三种场景:

  1. 指向静态的方法的引用。如Integer中的静态方法parseInt,可以通过Integer::parseInt来引用
  2. 指向任意类型实例方法的方法引用。如list.sort((s1, s2)->s1.compareToIgnoreCase(s2));, 可以修改为list.sort(String::compareToIgnorecase),即满足arg0.someMethod(restArgs)语法
  3. 指向现有对象实例的方法引用,如类ClassA有一个实例classA,并且有一个方法someMethod,则可以通过classA::someMethod进行方法引用。
  4. 构造函数引用ClassName::new。对于有参数的构造函数,则需要结合已有的函数式接口进行引用。

下期预告

下一篇文章将会结合JAVA8中预定义的一些FunctionalInterface的源码来介绍如何使用这些函数式接口帮助我们编程。

  1. Consumer
  2. Supplier
  3. Predicate
  4. Function

并且会以JAVA8的comparing方法为例子,详细解释方法引用的使用

作者:raledong