高阶函数和Java的Lambda
2017年的第一天，我坐在独墅湖边，写下这篇文章。
独墅湖.jpeg
在数学和计算机科学中，高阶函数是至少满足下列一个条件的函数：
- 接受一个或多个函数作为输入
- 输出一个函数
java世界迎来新的一等公民——函数
java 8引入了函数式编程。函数式编程重点在函数，函数变成了Java世界里的一等公民，函数和其他值一样，可以到处被定义，可以作为参数传入另一个函数，也可以作为函数的返回值，返回给调用者。利用这些特性，可以灵活组合已有函数形成新的函数，可以在更高层次上对问题进行抽象。
使用高阶函数之前的求和、求平方和、求立方和的写法：
public class TestHighOrderFunction {
public static int identity(int x) {
return x;
}
public static int sum_integers(int a, int b) {
int sum = 0;
for (int i = a; i <= b; i++) {
sum += identity(i);
}
return sum;
}
public static int square(int x) {
return x * x;
}
public static int sum_square(int a, int b) {
int sum = 0;
for (int i = a; i <= b; i++) {
sum += square(i);
}
return sum;
}
public static double cube(int x) {
return x * x * x;
}
public static int sum_cubes(int a, int b) {
int sum = 0;
for (int i = a; i <= b; i++) {
sum += cube(i);
}
return sum;
}
public static void main(String[] a) {
System.out.println(sum_integers(1, 10)); // return 55
System.out.println(sum_square(1, 10)); // return 385
System.out.println(sum_cubes(1, 10)); // return 3025
}
}
我们发现sum_开头的方法里，代码很类似，三者唯一区别在于
sum += identity(i);
sum += square(i);
sum += cube(i);
在软件工程里有DRY(don't repeat yourself )的准则。我们来看看使用高阶函数怎样优化刚才的这些代码：
public interface Function {
int opera(int a);
}
public static void main(String[] a) {
Function identity = x->x;
Function square = x->x*x;
Function cube = x -> x*x*x;
System.out.println(sum(identity, 1,10)); // return 55
System.out.println(sum(square, 1,10)); // return 385
System.out.println(sum(cube, 1,10)); // return 3025
}
public static int sum(Function term, int a, int b) {
int sum = 0;
for (int i = a; i <= b; i++) {
sum += term.opera(i);
}
return sum;
}
得到的结果，跟上面的TestHighOrderFunction类中运行的结果是一样的。不过，这里的sum方法中使用了
sum += term.opera(i);
取代了原先的代码。term.opera(i)对应的是原先identity(i)、square(i)、cube(i)，在这里Function函数被当做参数进行传递。这就是高阶函数的特性。
对于for循环，我们还能用更优雅的方式进行优化，下面使用了递归的方式。
public interface Function {
int opera(int a);
}
public static void main(String[] a) {
Function identity = x->x;
Function square = x->x*x;
Function cube = x -> x*x*x;
Function inc = x->x+1; // 定义next函数
System.out.println(sum(identity, 1,inc,10)); // return 55
System.out.println(sum(square, 1,inc,10)); // return 385
System.out.println(sum(cube, 1,inc,10)); // return 3025
}
public static int sum(Function term, int a, Function next, int b) {
if (a>b) {
return 0;
} else {
return term.opera(a) + sum(term, next.opera(a), next, b);
}
}
@FunctionalInterface
在java 8之前我们使用Thread，可能是这样的
new Thread(new Runnable() {
public void run() {
System.out.println("test");
}
}).start();
由于Java 8引入了lambda表达式，我们可以这样写
new Thread(()->System.out.println("test"));
lambda表达式源于lambda演算。
Lambda演算可以被称为最小的通用程序设计语言。它包括一条变换规则（变量替换）和一条函数定义方式，Lambda演算之通用在于，任何一个可计算函数都能用这种形式来表达和求值。因而，它是等价于图灵机的。尽管如此，Lambda演算强调的是变换规则的运用，而非实现它们的具体机器。可以认为这是一种更接近软件而非硬件的方式。
我们点击Runnable的源码时，发现Runnable使用了@FunctionalInterface，这在java 8之前是没有的。
@FunctionalInterface
public interface Runnable {
/**
* When an object implementing interface <code>Runnable</code> is used
* to create a thread, starting the thread causes the object's
* <code>run</code> method to be called in that separately executing
* thread.
* <p>
* The general contract of the method <code>run</code> is that it may
* take any action whatsoever.
*
* @see java.lang.Thread#run()
*/
public abstract void run();
}
@FunctionalInterface是Java 8为函数式接口引入的一个新的注解。表明该接口是函数式接口，它只包含唯一一个抽象方法。任何可以接受一个函数式接口实例的地方，都可以用lambda表达式。
我们再来看一个匿名函数的例子。
button.setOnClickListener(new Button.OnClickListener(){
public void onClick(View v) {
Log.i(TAG,"点击button");
}
});
我们将匿名函数改成lambda表达式
button.setOnClickListener((v)-> Log.i(TAG,,"点击button"));
这样改造的好处在于，lambda对象的创建是通过字节码指令invokedynamic来完成的，减少了类型和实例的创建消耗。而匿名类需要新的对象的创建。
JDK中的函数式接口举例
java.lang.Runnable,
java.awt.event.ActionListener,
java.util.Comparator,
java.util.concurrent.Callable
java.util.function包下的接口，如Consumer、Predicate、Supplier等
简化的lambda——方法引用（Method Reference）
lambda已经简化了代码的写法，然而方法引用进一步简化了lambda的写法。
方法引用的使用方式：类名::方法名
| 类型 | 使用方式 | 备注 |
|---|---|---|
| 引用静态方法 | ContainingClass::staticMethodName | Integer::valueOf简化了i->Integer.valueOf(i)的写法 |
| 引用特定对象的实例方法 | containingObject::instanceMethodName | s::toString()简化了()->s.toString() |
| 引用特定类型的任意对象的实例方法 | ContainingType::methodName | System.out::println简化了(s)->System.out.println(s)，其中System.out表示的是PrintStream对象 |
| 引用构造函数 | ClassName::new | String::new简化了()->new String() |
我们来看一个简单的例子，对User按照name来进行排序，最初我们会这样写。
User u1 = new User("tony");
User u2 = new User("cafei");
User u3 = new User("aaron");
List<User> users = Arrays.asList(u1,u2,u3);
Collections.sort(users, new Comparator<User>(){
@Override
public int compare(User u1, User u2) {
return u1.getName().compareTo(u2.getName());
}
});
在java 8以后,Comparator增加了一个静态方法comparing(Function<? super T, ? extends U> keyExtractor)，我们可以把排序的写法简化成这样:
Collections.sort(users, Comparator.comparing((User u)->u.getName()));
如果使用方法引用，还可以更加简化代码
Collections.sort(users,Comparator.comparing(User::getName));
集合中的应用
在java 8中可以使用新增的api Streams来操作集合，Streams是区别于java.io包里的InputStream 和 OutputStream的概念，是对集合功能的增强。如果你曾经了解过Scala、RxJava等函数式编程，那么看了它的语法以后一定会觉得似曾相识。我们来看两段代码，看看它是如何使用的。
List<Integer> list = Arrays.asList(1, 2, 3, 5, 7, 9, 10)
.stream()
.filter(i -> i >= 5)
.collect(Collectors.toList());
System.out.println("list=" + list); // return list=[5, 7, 9, 10]
Arrays.asList("tony", "cafei", "aaron")
.stream()
.map(str -> str.toUpperCase())
.forEach(it -> System.out.println(it));
上面的代码还可以使用方法引用的方式：
Arrays.asList("tony", "cafei", "aaron")
.stream()
.map(String::toUpperCase)
.forEach(System.out::println);
使用这样的链式调用非常cool。而且，map、filter等方法都是高阶函数。
写在最后
lambda是java 8最为重要的特性，lambda表达式并非只是Java的语法糖，而是由编译器和JVM共同配合来实现的。自从使用了lambda以后我感觉再也回不去了。
