Java函数式编程和lambda表达式

时间 2019-11-06

原文原文链接

为何要使用函数式编程

函数式编程更多时候是一种编程的思惟方式，是种方法论。函数式与命令式编程的区别主要在于：函数式编程是告诉代码你要作什么，而命令式编程则是告诉代码要怎么作。说白了，函数式编程是基于某种语法或调用API去进行编程。例如，咱们如今须要从一组数字中，找出最小的那个数字，若使用用命令式编程实现这个需求的话，那么所编写的代码以下：html

public static void main(String[] args) {
    int[] nums = new int[]{1, 2, 3, 4, 5, 6, 7, 8};

    int min = Integer.MAX_VALUE;
    for (int num : nums) {
        if (num < min) {
            min = num;
        }
    }
    System.out.println(min);
}

而使用函数式编程进行实现的话，所编写的代码以下：java

public static void main(String[] args) {
    int[] nums = new int[]{1, 2, 3, 4, 5, 6, 7, 8};

    int min = IntStream.of(nums).min().getAsInt();
    System.out.println(min);
}

从以上的两个例子中，能够看出，命令式编程须要本身去实现具体的逻辑细节。而函数式编程则是调用API完成需求的实现，将本来命令式的代码写成一系列嵌套的函数调用，在函数式编程下显得代码更简洁、易懂，这就是为何要使用函数式编程的缘由之一。因此才说函数式编程是告诉代码你要作什么，而命令式编程则是告诉代码要怎么作，是一种思惟的转变。编程

说到函数式编程就不得不提一下lambda表达式，它是函数式编程的基础。在Java还不支持lambda表达式时，咱们须要建立一个线程的话，须要编写以下代码：数组

public static void main(String[] args) {
    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("running");
        }
    }).start();
}

而使用lambda表达式一句代码就能完成线程的建立，lambda强调了函数的输入输出，隐藏了过程的细节，而且能够接受函数看成输入（参数）和输出（返回值）：bash

public static void main(String[] args) {
    new Thread(() -> System.out.println("running")).start();
}

注：箭头的左边是输入，右边则是输出app

该lambda表达式的做用其实就是返回了Runnable接口的实现对象，这与咱们调用某个方法获取实例对象相似，只不过是将实现代码直接写在了lambda表达式里。咱们能够作个简单的对比：ide

public static void main(String[] args) {
    Runnable runnable1 = () -> System.out.println("running");
    Runnable runnable2 = RunnableFactory.getInstance();
}

JDK8接口新特性

1.函数接口，接口只能有一个须要实现的方法，可使用@FunctionalInterface 注解进行声明。以下：函数式编程

@FunctionalInterface
interface Interface1 {
    int doubleNum(int i);
}

使用lambda表达式获取该接口的实现实例的几种写法：函数

public static void main(String[] args) {
    // 最多见的写法
    Interface1 i1 = (i) -> i * 2;
    Interface1 i2 = i -> i * 2;

    // 能够指定参数类型
    Interface1 i3 = (int i) -> i * 2;

    // 如有多行代码能够这么写
    Interface1 i4 = (int i) -> {
        System.out.println(i);
        return i * 2;
    };
}

2.比较重要的一个接口特性是接口的默认方法，用于提供默认实现。默认方法和普通实现类的方法同样，可使用this等关键字：学习

@FunctionalInterface
interface Interface1 {
    int doubleNum(int i);

    default int add(int x, int y) {
        return x + y;
    }
}

之因此说默认方法这个特性比较重要，是由于咱们借助这个特性能够在之前所编写的一些接口上提供默认实现，而且不会影响任何的实现类以及既有的代码。例如咱们最熟悉的List接口，在JDK1.2以来List接口就没有改动过任何代码，到了1.8以后才使用这个新特性增长了一些默认实现。这是由于若是没有默认方法的特性的话，修改接口代码带来的影响是巨大的，而有了默认方法后，增长默认实现能够不影响任何的代码。

3.当接口多重继承时，可能会发生默认方法覆盖的问题，这时能够去指定使用哪个接口的默认方法实现，以下示例：

@FunctionalInterface
interface Interface1 {
    int doubleNum(int i);

    default int add(int x, int y) {
        return x + y;
    }
}

@FunctionalInterface
interface Interface2 {
    int doubleNum(int i);

    default int add(int x, int y) {
        return x + y;
    }
}

@FunctionalInterface
interface Interface3 extends Interface1, Interface2 {

    @Override
    default int add(int x, int y) {
        // 指定使用哪个接口的默认方法实现
        return Interface1.super.add(x, y);
    }
}

函数接口

咱们本小节来看看JDK8里自带了哪些重要的函数接口：

能够看到上表中有好几个接口，而其中最经常使用的是Function接口，它能为咱们省去定义一些没必要要的函数接口，减小接口的数量。咱们使用一个简单的例子演示一下 Function 接口的使用：

import java.text.DecimalFormat;
import java.util.function.Function;

class MyMoney {
    private final int money;

    public MyMoney(int money) {
        this.money = money;
    }

    public void printMoney(Function<Integer, String> moneyFormat) {
        System.out.println("个人存款: " + moneyFormat.apply(this.money));
    }
}

public class MoneyDemo {
    public static void main(String[] args) {
        MyMoney me = new MyMoney(99999999);

        Function<Integer, String> moneyFormat = i -> new DecimalFormat("#,###").format(i);
        // 函数接口支持链式操做，例如增长一个字符串
        me.printMoney(moneyFormat.andThen(s -> "人民币 " + s));
    }
}

运行以上例子，控制台输出以下：

个人存款: 人民币 99,999,999

若在这个例子中不使用Function接口的话，则须要自行定义一个函数接口，而且不支持链式操做，以下示例：

import java.text.DecimalFormat;

// 自定义一个函数接口
@FunctionalInterface
interface IMoneyFormat {
    String format(int i);
}

class MyMoney {
    private final int money;

    public MyMoney(int money) {
        this.money = money;
    }

    public void printMoney(IMoneyFormat moneyFormat) {
        System.out.println("个人存款: " + moneyFormat.format(this.money));
    }
}

public class MoneyDemo {
    public static void main(String[] args) {
        MyMoney me = new MyMoney(99999999);

        IMoneyFormat moneyFormat = i -> new DecimalFormat("#,###").format(i);
        me.printMoney(moneyFormat);
    }
}

而后咱们再来看看Predicate接口和Consumer接口的使用，以下示例：

public static void main(String[] args) {
    // 断言函数接口
    Predicate<Integer> predicate = i -> i > 0;
    System.out.println(predicate.test(-9));

    // 消费函数接口
    Consumer<String> consumer = System.out::println;
    consumer.accept("这是输入的数据");
}

运行以上例子，控制台输出以下：

false
这是输入的数据

这些接口通常有对基本类型的封装，使用特定类型的接口就不须要去指定泛型了，以下示例：

public static void main(String[] args) {
    // 断言函数接口
    IntPredicate intPredicate = i -> i > 0;
    System.out.println(intPredicate.test(-9));

    // 消费函数接口
    IntConsumer intConsumer = (value) -> System.out.println("输入的数据是：" + value);
    intConsumer.accept(123);
}

运行以上代码，控制台输出以下：

false
输入的数据是：123

有了以上接口示例的铺垫，咱们应该对函数接口的使用有了一个初步的了解，接下来咱们演示剩下的函数接口使用方式：

public static void main(String[] args) {
    // 提供数据接口
    Supplier<Integer> supplier = () -> 10 + 1;
    System.out.println("提供的数据是：" + supplier.get());

    // 一元函数接口
    UnaryOperator<Integer> unaryOperator = i -> i * 2;
    System.out.println("计算结果为：" + unaryOperator.apply(10));

    // 二元函数接口
    BinaryOperator<Integer> binaryOperator = (a, b) -> a * b;
    System.out.println("计算结果为：" + binaryOperator.apply(10, 10));
}

运行以上代码，控制台输出以下：

提供的数据是：11
计算结果为：20
计算结果为：100

而BiFunction接口就是比Function接口多了一个输入而已，以下示例：

class MyMoney {
    private final int money;
    private final String name;

    public MyMoney(int money, String name) {
        this.money = money;
        this.name = name;
    }

    public void printMoney(BiFunction<Integer, String, String> moneyFormat) {
        System.out.println(moneyFormat.apply(this.money, this.name));
    }
}

public class MoneyDemo {
    public static void main(String[] args) {
        MyMoney me = new MyMoney(99999999, "小明");

        BiFunction<Integer, String, String> moneyFormat = (i, name) -> name + "的存款: " + new DecimalFormat("#,###").format(i);
        me.printMoney(moneyFormat);
    }
}

运行以上代码，控制台输出以下：

小明的存款: 99,999,999

方法引用

在学习了lambda表达式以后，咱们一般会使用lambda表达式来建立匿名方法。但有的时候咱们仅仅是须要调用一个已存在的方法。以下示例：

Arrays.sort(stringsArray, (s1, s2) -> s1.compareToIgnoreCase(s2));

在jdk8中，咱们能够经过一个新特性来简写这段lambda表达式。以下示例：

Arrays.sort(stringsArray, String::compareToIgnoreCase);

这种特性就叫作方法引用(Method Reference)。方法引用的标准形式是：类名::方法名。（注意：只须要写方法名，不须要写括号）。

目前方法引用共有如下四种形式：

类型	示例	代码示例	对应的Lambda表达式
引用静态方法	ContainingClass::staticMethodName	String::valueOf	(s) -> String.valueOf(s)
引用某个对象的实例方法	containingObject::instanceMethodName	x::toString()	() -> this.toString()
引用某个类型的任意对象的实例方法	ContainingType::methodName	String::toString	(s) -> s.toString
引用构造方法	ClassName::new	String::new	() -> new String()

下面咱们用一个简单的例子来演示一下方法引用的几种写法。首先定义一个实体类：

public class Dog {
    private String name = "二哈";
    private int food = 10;

    public Dog() {
    }

    public Dog(String name) {
        this.name = name;
    }

    public static void bark(Dog dog) {
        System.out.println(dog + "叫了");
    }

    public int eat(int num) {
        System.out.println("吃了" + num + "斤");
        this.food -= num;
        return this.food;
    }

    @Override
    public String toString() {
        return this.name;
    }
}

经过方法引用来调用该实体类中的方法，代码以下：

package org.zero01.example.demo;

import java.util.function.*;

/**
 * @ProjectName demo
 * @Author: zeroJun
 * @Date: 2018/9/21 13:09
 * @Description: 方法引用demo
 */
public class MethodRefrenceDemo {

    public static void main(String[] args) {
        // 方法引用，调用打印方法
        Consumer<String> consumer = System.out::println;
        consumer.accept("接收的数据");

        // 静态方法引用，经过类名便可调用
        Consumer<Dog> consumer2 = Dog::bark;
        consumer2.accept(new Dog());

        // 实例方法引用，经过对象实例进行引用
        Dog dog = new Dog();
        IntUnaryOperator function = dog::eat;
        System.out.println("还剩下" + function.applyAsInt(2) + "斤");

        // 另外一种经过实例方法引用的方式，之因此能够这么干是由于JDK默认会把当前实例传入到非静态方法，参数名为this，参数位置为第一个，因此咱们在非静态方法中才能访问this，那么就能够经过BiFunction传入实例对象进行实例方法的引用
        Dog dog2 = new Dog();
        BiFunction<Dog, Integer, Integer> biFunction = Dog::eat;
        System.out.println("还剩下" + biFunction.apply(dog2, 2) + "斤");

        // 无参构造函数的方法引用，相似于静态方法引用，只须要分析好输入输出便可
        Supplier<Dog> supplier = Dog::new;
        System.out.println("建立了新对象：" + supplier.get());

        // 有参构造函数的方法引用
        Function<String, Dog> function2 = Dog::new;
        System.out.println("建立了新对象：" + function2.apply("旺财"));
    }
}

最后须要说一句的就是可以使用方法引用的地方就尽可能不要使用lambda表达式，这样就不会多生成一个相似 lambda$0 这样的函数，可以减小一些资源的开销。

类型推断

经过以上的例子，咱们知道之因此可以使用Lambda表达式的依据是必须有相应的函数接口。这一点跟Java是强类型语言吻合，也就是说你并不能在代码的任何地方任性的写Lambda表达式。实际上Lambda的类型就是对应函数接口的类型。Lambda表达式另外一个依据是类型推断机制，在上下文信息足够的状况下，编译器能够推断出参数表的类型，而不须要显式指名。

因此说 Lambda 表达式的类型是从 Lambda 的上下文推断出来的，上下文中 Lambda 表达式须要的类型称为目标类型，以下图所示：

接下来咱们使用一个简单的例子，演示一下 Lambda 表达式的几种类型推断，首先定义一个简单的函数接口：

@FunctionalInterface
interface IMath {
    int add(int x, int y);
}

示例代码以下：

public class TypeDemo {

    public static void main(String[] args) {
        // 1.经过变量类型定义
        IMath iMath = (x, y) -> x + y;

        // 2.数组构建的方式
        IMath[] iMaths = {(x, y) -> x + y};

        // 3.强转类型的方式
        Object object = (IMath) (x, y) -> x + y;

        // 4.经过方法返回值肯定类型
        IMath result = createIMathObj();

        // 5.经过方法参数肯定类型
        test((x, y) -> x + y);

    }

    public static IMath createIMathObj() {
        return (x, y) -> x + y;
    }

    public static void test(IMath iMath){
        return;
    }
}

变量引用

Lambda表达式相似于实现了指定接口的内部类或者说匿名类，因此在Lambda表达式中引用变量和咱们在匿名类中引用变量的规则是同样的。以下示例：

public static void main(String[] args) {
    String str = "当前的系统时间戳是: ";
    Consumer<Long> consumer = s -> System.out.println(str + s);
    consumer.accept(System.currentTimeMillis());
}

值得一提的是，在JDK1.8以前咱们通常会将匿名类里访问的外部变量设置为final，而在JDK1.8里默认会将这个匿名类里访问的外部变量给设置为final。例如我如今改变str变量的值，ide就会提示错误：

至于为何要将变量设置final，这是由于在Java里没有引用传递，变量都是值传递的。不将变量设置为final的话，若是外部变量的引用被改变了，那么最终得出来的结果就会是错误的。

下面用一组图片简单演示一下值传递与引用传递的区别。以列表为例，当只是值传递时，匿名类里对外部变量的引用是一个值对象：

若此时list变量指向了另外一个对象，那么匿名类里引用的仍是以前那个值对象，因此咱们才须要将其设置为final防止外部变量引用改变：

而若是是引用传递的话，匿名类里对外部变量的引用就不是值对象了，而是指针指向这个外部变量：

因此就算list变量指向了另外一个对象，匿名类里的引用也会随着外部变量的引用改变而改变：

级联表达式和柯里化

在函数式编程中，函数既能够接收也能够返回其余函数。函数再也不像传统的面向对象编程中同样，只是一个对象的工厂或生成器，它也可以建立和返回另外一个函数。返回函数的函数能够变成级联 lambda 表达式，特别值得注意的是代码很是简短。尽管此语法初看起来可能很是陌生，但它有本身的用途。

级联表达式就是多个lambda表达式的组合，这里涉及到一个高阶函数的概念，所谓高阶函数就是一个能够返回函数的函数，以下示例：

// 实现了 x + y 的级联表达式
Function<Integer, Function<Integer, Integer>> function1 = x -> y -> x + y;
System.out.println("计算结果为: " + function1.apply(2).apply(3));  // 计算结果为: 5

这里的 y -> x + y 是做为一个函数返回给上一级表达式，因此第一级表达式的输出是 y -> x + y 这个函数，若是使用括号括起来可能会好理解一些：

x -> (y -> x + y)

级联表达式能够实现函数柯里化，简单来讲柯里化就是把原本多个参数的函数转换为只有一个参数的函数，以下示例：

Function<Integer, Function<Integer, Function<Integer, Integer>>> function2 = x -> y -> z -> x + y + z;
System.out.println("计算结果为: " + function2.apply(1).apply(2).apply(3));  // 计算结果为: 6

函数柯里化的目的是将函数标准化，函数可灵活组合，方便统一处理等，例如我能够在循环里只须要调用同一个方法，而不须要调用另外的方法就能实现一个数组内元素的求和计算，代码以下：

public static void main(String[] args) {
    Function<Integer, Function<Integer, Function<Integer, Integer>>> f3 = x -> y -> z -> x + y + z;
    int[] nums = {1, 2, 3};
    for (int num : nums) {
        if (f3 instanceof Function) {
            Object obj = f3.apply(num);
            if (obj instanceof Function) {
                f3 = (Function) obj;
            } else {
                System.out.println("调用结束, 结果为: " + obj);  // 调用结束, 结果为: 6
            }
        }
    }
}

级联表达式和柯里化通常在实际开发中并非很常见，因此对其概念稍有理解便可，这里只是简单带过，若对其感兴趣的能够查阅相关资料。

参考：

https://www.ibm.com/developerworks/cn/java/j-java8idioms9/index.html