Java8之lambda表示式
簡述
Java8釋出了很多的新特性，其中lambda表示式是一個重要的部分
（雖然Java11已經發布了 ⊙▽⊙）
1、先來看一個新建執行緒的例子
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println(666);
}
});
在Thread的建構函式中傳入Runnable例項，由於Runnable是一個介面，所以需要實現其中的抽象方法run
2、改為lambda表示式後
Thread t1 = new Thread(() -> System.out.println(666));
嘿嘿嘿，是不是異常簡潔呢？
通過感性的對比，我們大致可以發現，()代表run方法名， 箭頭和後面的語句表示定義整個方法體。這裡我們會有疑問，轉換為簡潔的lambda表示式需要什麼約束呢？下面我們開始介紹！
函式式介面
- 只有函式式介面，才可以轉換為lambda表示式，什麼是函式式介面呢？
- 有且只有一個抽象方法的介面被成為函式式介面！
- 函式式介面可以顯式的被@FunctionalInterface所表示，當被標識的介面不滿足規定時，編譯器會提示報錯
Runnable介面就是一個函式式介面
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
轉換方式
1、當函式式介面內的唯一抽象方法沒有引數時，可以使用如下方式
//如果方法體內只有一條語句
//無返回值
() -> System.out.println("test");
//有返回值，不需要顯示的return
() -> new Student();
//如果有多條語句，需要用{}包圍
//無返回值
() -> {
int a = 1;
int b = 2;
System.out.println(a * b);
};
//有返回值
() -> {
int a = 1;
int b = 2;
return a * b;
};
2、當函式式介面內的唯一抽象方法含有引數時，寫法與上面基本相同，只是需要把對應引數寫到()裡面
//不需要指明引數型別，會根據實際方法中的型別自動推測 //只有一個引數可以省略括號 (arg1, arg2, arg3) -> System.out.println(arg1 * arg2 * arg3);
3、舉個例子
//自定義一個函式式介面
@FunctionalInterface
public interface MyInterface {
void method(int a, int b);
}
//使用lambda表示式
public static void main(String[] args) {
MyInterface myInterface = (a, b) -> System.out.println(a + b);
myInterface.method(1, 2);//3
}
意義
首先毋庸置疑，lambda表示式十分簡潔。
其次，在傳統的java面向物件程式設計中，我們在方法內只可以傳遞值或物件引用，無法傳遞方法。
當我們想要在方法中傳遞方法，或者說是傳遞行為的時候，如Java Swing或者Android開發中，經常需要我們實現監聽介面中的方法，這就是一種行為的傳遞。
private Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
//程式碼省略
}
};
這種行為的傳遞需要依賴介面實現類例項，但是我們只關心方法內部的邏輯實現，所以使用lambda表示式可以實現這一目標
private Handler handler = msg -> {
//程式碼省略
};
//但實際上lambda並沒有脫離介面，仍然依附於介面實現類例項
Java8內建的函式式介面
Java8提供了一個java.util.function包，包含了很多函式式介面，我們來介紹最為基本的4個（為了節省篇幅，去掉了原始碼中的註釋）
Function介面
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
static <T> Function<T, T> identity() {
return t -> t;
}
}
Function介面的唯一抽象方法是apply，作用是接收一個指定型別的引數，返回一個指定型別的結果
import java.util.function.Function;
public class FunctionTest {
public static void main(String[] args) {
FunctionTest ft = new FunctionTest();
//使用lambda表示式實現apply方法，返回入參+10。形式上如同傳遞了一個方法作為引數
int res = ft.compute(1, v -> v + 10);
System.out.println(res);//11
}
public int compute(int a, Function<Integer, Integer> function){
//使用者在使用本方法時，需要去編寫自己的apply，
//傳遞的funtion是一個行為方法，而不是一個值
return function.apply(a);
}
預設方法compose作用是傳入引數後，首先執行compose方法內的Function的apply方法，然後將其返回值作為本Function方法的入參，呼叫apply後得到最後返回值
import java.util.function.Function;
public class FunctionTest {
public static void main(String[] args) {
FunctionTest ft = new FunctionTest();
//呼叫compose
//先+8，然後將得到的值*3
System.out.println(ft.compute(2, v -> v * 3, v -> v + 8));//30
}
public int compute(int a, Function<Integer, Integer> function1, Function<Integer, Integer> function2){
//將function2先接收入參a，呼叫apply後，將返回值作為新的入參，傳入function1，呼叫apply返回最後結果
return function1.compose(function2).apply(a);
}
預設方法andThen與compose正好相反，先執行本Function的apply，然後將結果作為andThen方法引數內的Function的入參，呼叫apply後返回最後結果
import java.util.function.Function;
public class FunctionTest {
public static void main(String[] args) {
FunctionTest ft = new FunctionTest();
//呼叫andThen
//先*3，然後將得到的值+8
System.out.println(ft.compute(2, v -> v * 3, v -> v + 8));//14
}
public int compute(int a, Function<Integer, Integer> function1, Function<Integer, Integer> function2){
//將function2先接收入參a，呼叫apply後，將返回值作為新的入參，傳入function1，呼叫apply返回最後結果
return function1.andThen(function2).apply(a);
}
靜態方法identity的作用是傳入啥返回啥，這裡就不寫例子了
Consumer介面
package java.util.function;
import java.util.Objects;
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
}
Consumer介面中accept方法的作用是接收指定引數型別，無返回值，重點在於內部消費
Consumer<String> consumer = s -> System.out.println("hello " + s);
consumer.accept("mike");// hello mike
預設方法andThen作用是連續消費，從本Consumer開始，從外到內，針對同一入參。
Consumer<String> consumer = s -> System.out.println("hello " + s);
Consumer<String> consumer2 = s -> System.out.println("nice to meet you " + s);
consumer.andThen(consumer2).accept("mike");
//hello mike
//nice to meet you mike
Predicate介面
package java.util.function;
import java.util.Objects;
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
default Predicate<T> negate() {
return (t) -> !test(t);
}
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}
Predicate中的test方法，傳入指定型別引數，返回布林型別的結果，用於判斷，斷言
//判斷一個數是否是偶數 Predicate<Integer> predicate = b -> n % 2 == 0; System.out.println(predicate.test(3)); //false
預設方法and顧名思義，將本Predicate和and引數中的Predicate對同一入參進行test的結果進行【與】操作。
negate方法對test的結果進行【非】操作
or方法對兩個Predicate的test結果進行【或】操作
靜態方法isEqual將其入參與test方法的入參進行equals比較
System.out.println(Predicate.isEqual(1).test(1));//true
Supplier介面
package java.util.function;
@FunctionalInterface
public interface Supplier<T> {
T get();
}
Supplier意為供應，只有一個方法get，不接收任何引數，只返回指定型別結果
Supplier<String> sup = () -> "hello world"; System.out.println(sup.get());
總結
以上就是function包中最為基礎的四個函式式介面，不管是介面名稱還是方法名稱，都是見名知意，十分形象。
當然funtion包下還有很多其他介面，但基本都與這四個介面有關。如BiFunction是接收兩個引數，DoubleConsumer是強制接收double型別的引數，更多函式式介面點進去原始碼一看註釋便知道如何使用！