本文不讲解JDK8函数式编程的具体API,而是解释函数式编程的概念。但是弄懂原理是学习API的前提,纲举目张才能事半功倍。

众所周知,JDK8引入了函数式编程。什么是函数式编程呢?为何需要函数式编程呢?
认知决定高度。首先函数式编程是与面向对象编程一个层级的概念。

任何Java程序员都不可能不知道面向对象编程OOP。OOP的口号是“万物皆对象”。什么是对象呢?就是现实中一个东西在编程领域的投射。对象有属性,有方法。属性表示数据,方法表示行为。对象可以用来表示任何事物,非常强大。既然如此,为何又需要函数式编程呢?

什么是函数

函数式编程来自数学。有点(gaozhong)数学功底的你一定不会忘记这个东东:
我是认真的在解释JDK8函数式编程 - 图1

数学中的函数表示的是什么呢?其实就是一个计算过程。编程领域也是一样的, 函数表示了一个计算过程,比如,加减乘除,取余等等。就是我们java的方法的作用。

你肯定要问,那java中有方法了啊,为何又弄个什么函数式编程出来呢?问题在于,java中的方法是“二等公民”,它只能依附于对象存在,而不能独立存在。

JS中的函数与Java中的方法比较

这方面我们可以把java与js放在一起比较。在js中,函数是一等公民,你可以直接声明函数,使用函数。如下例所示。

  1. //将函数定义为变量
  2. var add = function(a,b){
  3. return a+b;
  4. }
  5. var minus = function(a,b){
  6. return a-b;
  7. }
  8. //定义一个计算函数,第一个参数是个函数,注意我们已经开始传递函数了
  9. function calc(fn,a,b){
  10. return fn(a,b);//调用函数fn,将a,b传入
  11. }
  12. //调用calc
  13. //传入add函数作为第一个参数
  14. var r1 = calc(add,10,5);
  15. console.log("r1:"+r1)
  16. //传入minus函数作为第一个参数
  17. var r2 = calc(minus,10,5);
  18. console.log("r2:"+r2)

在这里我们也看到,函数的好处是可以封装一段算法,一个计算过程,一个行为。这是对象无法做到的。但是好处却很显然,calc的第一个参数是个函数,在不改变calc方法的前提下,可以非常容易的扩展出各种算法。只需要提供不同函数实现即可。因为函数封装了算法。

这在java中是无法直接实现的。必须绕个弯。我们需要将函数放在一个接口中。代码如下:

  1. package com.woniuxy.test;
  2. /**
  3. * 表示一个计算接口,这个接口存在的唯一用处就是存放calc方法
  4. */
  5. public interface Fn {
  6. //计算函数的抽象方法
  7. double calc(double a,double b);
  8. }
  9. //实现加法
  10. package com.woniuxy.test;
  11. public class Add implements Fn {
  12. @Override
  13. public double calc(double a, double b) {
  14. return a+b;
  15. }
  16. }
  17. //实现减法
  18. package com.woniuxy.test;
  19. public class Minus implements Fn {
  20. @Override
  21. public double calc(double a, double b) {
  22. return a-b;
  23. }
  24. }
  25. //计算器类
  26. package com.woniuxy.test;
  27. public class Calculator {
  28. /**
  29. * 接受Fn接口作为参数,根据多态性,Fn可以传入Add和Minus
  30. */
  31. public double calc(Fn fn, double a, double b){
  32. return fn.calc(a,b);
  33. }
  34. }

最后我们来组装一下,代码与上面的js代码就非常接近了。

  1. //调用测试
  2. package com.woniuxy.test;
  3. public class App {
  4. public static void main(String[] args) {
  5. //声明函数实例
  6. Fn add = new Add();
  7. Fn minus = new Minus();
  8. Calculator c = new Calculator();
  9. //调用
  10. double r1 = c.calc(add,10,5);
  11. System.out.println("r1:"+r1);
  12. double r2 = c.calc(minus,10,5);
  13. System.out.println("r2:"+r2);
  14. }
  15. }

我们来看,同样的计算逻辑,为何js为java要简单呢?因为java是oop的,基于对象。所以必须现有Fn接口才能有calc方法、必须现有Add类才能有calc方法的实现。方法必须依赖于对象。而JavaScript中函数是“一等公民”,可以直接创建。

引入函数式编程

为了简化这类代码,JDK8引入了函数式编程,终于Java也可以直接使用函数啦。
这里我们先给出BiFunction 这个接口,这个接口表示一个接受两个参数的函数,有三个泛型分别表示第一个参数的类型和第二个参数的类型以及返回值类型。所以可以直接用BiFunction来表示我们的这里的加减乘除的函数。

  1. //修改Calculator.java,接受BiFunction作为第一个参数
  2. public double calc2(BiFunction<Double,Double,Double> fn,double a,double b){
  3. return fn.apply(a,b);
  4. }
  5. //不再创建Fn、Add和Minus了,直接用BiFunction表示操作
  6. public class App {
  7. public static void main(String[] args) {
  8. //直接用BiFunction封装加法运算
  9. BiFunction<Double,Double,Double> add =new BiFunction<Double, Double, Double>() {
  10. @Override
  11. public Double apply(Double a, Double b) {
  12. return a+b;
  13. }
  14. };
  15. //直接用BiFunction封装减法运算
  16. BiFunction<Double,Double,Double> minus =new BiFunction<Double, Double, Double>() {
  17. @Override
  18. public Double apply(Double a, Double b) {
  19. return a-b;
  20. }
  21. };
  22. }
  23. }

显然一下子少了3个类,比刚才简单了一些,但是 BiFunction<Double,Double,Double> 仍然看着头大呀。有简化的办法吗?

引入lambda表达式

是了,就是jdk8引入的lambda表达式。先看效果

  1. //直接用BiFunction封装加法运算
  2. BiFunction<Double,Double,Double> add = (a, b) -> a+b;
  3. //直接用BiFunction封装减法运算
  4. BiFunction<Double,Double,Double> minus = (a, b) -> a-b;
  5. Calculator c = new Calculator();
  6. //传入函数
  7. double r1 = c.calc2(add,10,5);
  8. System.out.println("r1:"+r1);
  9. double r2 = c.calc2(minus,10,5);
  10. System.out.println("r2:"+r2);

感觉如何?已经无限接近js的代码简洁程度了。

No Magic

代码是清晰了,但是你可能没弄明白是怎么回事。

  1. BiFunction<Double,Double,Double> add =new BiFunction<Double, Double, Double>() {
  2. @Override
  3. public Double apply(Double a, Double b) {
  4. return a+b;
  5. }
  6. };
  7. //被转换成了
  8. BiFunction<Double,Double,Double> add = (a, b) -> a+b;

这是怎么做到的呢?

道理其实很简单。BiFunction接口只有一个方法apply,而BiFunction存在的意义就是为这个方法提供载体。换言之,我们使用BiFunction接口就是奔着apply方法去的。既然如此,为何不直接把那个方法表示出来呢?jdk就提供了一种简洁的表示法,称为lambda表达式,直接表示出了接口里的方法。

反过来想一下,因为接口只有一个方法,所以非常明确的定位到这个方法。这里就是apply方法。并不会混淆。但是为何a,b参数都没有类型了呢?当然是为了简化代码,但其实是参数类型可以进行推断出来的。我们通过反射能够得到BiFunction的泛型参数,根据约定就可以知道a和b的类型了。有了这些约定,jdk可以获取到足够的信息,自动将lambda表达式转换为匿名内部类。

到这里,我们了解到JDK函数式编程的优势了。同样的封装计算过程(Add、Minus),传统的方式和函数式编程的差别是非常大的。

一些实例

事已至此,我们不如来看几个例子,感受下函数式编程的惊人魅力。请留意,lambda表达式都是在封装算法。

  1. package com.woniuxy.examples;
  2. import java.util.Arrays;
  3. import java.util.Collections;
  4. import java.util.List;
  5. import java.util.function.Function;
  6. import java.util.stream.Collectors;
  7. public class Sorting {
  8. private static List<Person> personList = Arrays.asList(new Person(20,"Dido")
  9. ,new Person(15,"Guava")
  10. ,new Person(30,"Alina")
  11. ,new Person(28,"Crack")
  12. );
  13. public static void main(String[] args) {
  14. //0)封装sqrt,虽然有点多此一举
  15. Function<Double,Double> sqrt = (number)->Math.sqrt(number);
  16. System.out.println(sqrt.apply(9.0));;
  17. //1)封装排序算法
  18. //按年龄排序
  19. Collections.sort(personList,(p1,p2)-> p1.getAge()-p2.getAge());
  20. System.out.println(personList);
  21. //按姓名排序
  22. Collections.sort(personList,(p1,p2)-> p1.getName().compareTo(p2.getName()));
  23. System.out.println(personList);
  24. //2)封装选择算法
  25. //选出18岁及以上的人
  26. List<Person> adultList = personList.stream()//这里用到了List的StreamAPI
  27. .filter((person -> person.getAge()>=18))//lambda表达式
  28. .collect(Collectors.toList());
  29. System.out.println(adultList);
  30. //3)封装Runnable里的run方法,妈妈再也不用担心我写Runnable累死了
  31. new Thread(()->{
  32. for (int i = 0; i < 10; i++) {
  33. System.out.println(Thread.currentThread().getName()+":"+i);
  34. }
  35. }).start();
  36. }
  37. }
  38. class Person{
  39. private int age;
  40. private String name;
  41. public Person(int age, String name) {
  42. this.age = age;
  43. this.name = name;
  44. }
  45. //...省略setter、getter
  46. @Override
  47. public String toString() {
  48. return "Person{" +
  49. "age=" + age +
  50. ", name='" + name + '\'' +
  51. '}';
  52. }
  53. }

小结

JDK8函数式编程提供了一种直接封装函数的方式,即提供了一系列预定义的Function接口,提供了封装函数所需的功能。并通过lambda表达式简化了函数的编写方式。