2017年的第一天，我坐在獨(dú)墅湖邊，寫下這篇文章。
在數(shù)學(xué)和計(jì)算機(jī)科學(xué)中，高階函數(shù)是至少滿足下列一個(gè)條件的函數(shù)：
- 接受一個(gè)或多個(gè)函數(shù)作為輸入
- 輸出一個(gè)函數(shù)
java世界迎來(lái)新的一等公民——函數(shù)
java 8引入了函數(shù)式編程。函數(shù)式編程重點(diǎn)在函數(shù)，函數(shù)變成了Java世界里的一等公民，函數(shù)和其他值一樣，可以到處被定義，可以作為參數(shù)傳入另一個(gè)函數(shù)，也可以作為函數(shù)的返回值，返回給調(diào)用者。利用這些特性，可以靈活組合已有函數(shù)形成新的函數(shù)，可以在更高層次上對(duì)問(wèn)題進(jìn)行抽象。
使用高階函數(shù)之前的求和、求平方和、求立方和的寫法：
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
}
}
我們發(fā)現(xiàn)sum_開(kāi)頭的方法里，代碼很類似，三者唯一區(qū)別在于
sum += identity(i);
sum += square(i);
sum += cube(i);
在軟件工程里有DRY(don't repeat yourself )的準(zhǔn)則。我們來(lái)看看使用高階函數(shù)怎樣優(yōu)化剛才的這些代碼：
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;
}
得到的結(jié)果，跟上面的TestHighOrderFunction類中運(yùn)行的結(jié)果是一樣的。不過(guò)，這里的sum方法中使用了
sum += term.opera(i);
取代了原先的代碼。term.opera(i)對(duì)應(yīng)的是原先identity(i)、square(i)、cube(i)，在這里Function函數(shù)被當(dāng)做參數(shù)進(jìn)行傳遞。這就是高階函數(shù)的特性。
對(duì)于for循環(huán)，我們還能用更優(yōu)雅的方式進(jìn)行優(yōu)化，下面使用了遞歸的方式。
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函數(shù)
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表達(dá)式，我們可以這樣寫
new Thread(()->System.out.println("test")).start();
lambda表達(dá)式源于lambda演算。
Lambda演算可以被稱為最小的通用程序設(shè)計(jì)語(yǔ)言。它包括一條變換規(guī)則（變量替換）和一條函數(shù)定義方式，Lambda演算之通用在于，任何一個(gè)可計(jì)算函數(shù)都能用這種形式來(lái)表達(dá)和求值。因而，它是等價(jià)于圖靈機(jī)的。盡管如此，Lambda演算強(qiáng)調(diào)的是變換規(guī)則的運(yùn)用，而非實(shí)現(xiàn)它們的具體機(jī)器。可以認(rèn)為這是一種更接近軟件而非硬件的方式。
我們點(diǎn)擊Runnable的源碼時(shí)，發(fā)現(xiàn)Runnable使用了@FunctionalInterface，這在java 8之前是沒(méi)有的。
@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為函數(shù)式接口引入的一個(gè)新的注解。表明該接口是函數(shù)式接口，它只包含唯一一個(gè)抽象方法。任何可以接受一個(gè)函數(shù)式接口實(shí)例的地方，都可以用lambda表達(dá)式。
我們?cè)賮?lái)看一個(gè)匿名函數(shù)的例子。
button.setOnClickListener(new Button.OnClickListener(){
public void onClick(View v) {
Log.i(TAG,"點(diǎn)擊button");
}
});
我們將匿名函數(shù)改成lambda表達(dá)式
button.setOnClickListener((v)-> Log.i(TAG,,"點(diǎn)擊button"));
這樣改造的好處在于，lambda對(duì)象的創(chuàng)建是通過(guò)字節(jié)碼指令invokedynamic來(lái)完成的，減少了類型和實(shí)例的創(chuàng)建消耗。而匿名類需要新的對(duì)象的創(chuàng)建。
JDK中的函數(shù)式接口舉例
java.lang.Runnable,
java.awt.event.ActionListener,
java.util.Comparator,
java.util.concurrent.Callable
java.util.function包下的接口，如Consumer、Predicate、Supplier等
簡(jiǎn)化的lambda——方法引用（Method Reference）
lambda已經(jīng)簡(jiǎn)化了代碼的寫法，然而方法引用進(jìn)一步簡(jiǎn)化了lambda的寫法。
方法引用的使用方式：類名::方法名
| 類型 | 使用方式 | 備注 |
|---|---|---|
| 引用靜態(tài)方法 | ContainingClass::staticMethodName | Integer::valueOf簡(jiǎn)化了i->Integer.valueOf(i)的寫法 |
| 引用特定對(duì)象的實(shí)例方法 | containingObject::instanceMethodName | s::toString()簡(jiǎn)化了()->s.toString() |
| 引用特定類型的任意對(duì)象的實(shí)例方法 | ContainingType::methodName | System.out::println簡(jiǎn)化了(s)->System.out.println(s)，其中System.out表示的是PrintStream對(duì)象 |
| 引用構(gòu)造函數(shù) | ClassName::new | String::new簡(jiǎn)化了()->new String() |
我們來(lái)看一個(gè)簡(jiǎn)單的例子，對(duì)User按照name來(lái)進(jìn)行排序，最初我們會(huì)這樣寫。
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增加了一個(gè)靜態(tài)方法comparing(Function<? super T, ? extends U> keyExtractor)，我們可以把排序的寫法簡(jiǎn)化成這樣:
Collections.sort(users, Comparator.comparing((User u)->u.getName()));
如果使用方法引用，還可以更加簡(jiǎn)化代碼
Collections.sort(users,Comparator.comparing(User::getName));
集合中的應(yīng)用
在java 8中可以使用新增的api Streams來(lái)操作集合，Streams是區(qū)別于java.io包里的InputStream 和 OutputStream的概念，是對(duì)集合功能的增強(qiáng)。如果你曾經(jīng)了解過(guò)Scala、RxJava等函數(shù)式編程，那么看了它的語(yǔ)法以后一定會(huì)覺(jué)得似曾相識(shí)。我們來(lái)看兩段代碼，看看它是如何使用的。
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);
使用這樣的鏈?zhǔn)秸{(diào)用非常cool。而且，map、filter等方法都是高階函數(shù)。
寫在最后
lambda是java 8最為重要的特性，lambda表達(dá)式并非只是Java的語(yǔ)法糖，而是由編譯器和JVM共同配合來(lái)實(shí)現(xiàn)的。自從使用了lambda以后我感覺(jué)再也回不去了。
