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型別的引數,更多函式式介面點進去原始碼一看註釋便知道如何使用!