Java Lambda表達式

時間  2019-11-19
標籤 java lambda 表達式 欄目 Java 简体版
原文   原文鏈接

Java Lambda表達式

概念

函數式接口是指：有且僅有一個抽象方法的接口。java

函數式接口即適用於函數式編程場景的接口。而Java中函數式編程體現的就是Lambda，因此Lambda接口就是適用於Lambda使用的接口。有且只有一個抽象方法，Java中的Lambda才能順利推導。編程

格式

只要確保接口的有且僅有一個抽象方法便可:數組

修飾符 interface 接口{
    public abstract 返回值類型 方法名稱(可選參數信息);
    //其餘非抽象方法
}

接口中的public abstract能夠省略，因此格式能夠簡化：app

修飾符 interface 接口{
    返回值類型 方法名稱(可選參數信息);
    //其餘非抽象方法
}

函數式接口能夠做爲方法的參數和返回值類型函數式編程

@FunctionalInterface註解
@FunctionalInterface
修飾符 interface 接口{
    返回值類型 方法名稱(可選參數信息);
    //其餘非抽象方法
}

檢測該函數是不是函數式接口，是否有且僅有一個抽象方法。函數

自定義函數式接口
public class LambdaTest{
    public static void useLambdaInterfaceMethod(LambdaInterface lifm){
        lifm.LambdaInterfaceMethod();
    }
    public static void main(String[] args){
        //傳入接口的實現類：
        //useLambdaInterfaceMethod(new 接口的實現類);
        
        //傳入接口的匿名內部類
        /*
        useLambdaInterfaceMethod(new LambdaInterface(){
            public void LambdaInterfaceMethod(){
                System.out.println("這裏傳入的是接口的實現匿名內部類");
            }
        });
        */
        //抽象方法有且僅有一行語句，能夠省略大括號
        //ustLambdaInterfaceMethod(() -> System.out.println("..."));
        useLambdaInterfaceMethod(() -> {
            System.out.println("使用Lambda表達式，重寫接口中的抽象方法。")
                }
            );
    }
}
//註解FunctionanInterface檢測是否爲函數式接口
@FunctionalInterface
interface LambdaInterface{
    void LambdaInterfaceMethod();
}

函數式編程

Lambda的延遲執行

有些場景代碼執行之後，結果不必定使用，從而形成浪費。而Lambda表達式是延遲執行的，能夠做爲解決方案，提高性能。性能

性能浪費的日誌案例

日誌能夠快速定位問題，記錄程序運行中的狀況，以便項目的監控和優化。優化

一種場景是對參數進行有條件的使用，例如在日子消息拼接之後，在知足條件時打印輸出。ui

/*
    下面存在性能浪費的問題
    調用log方法的時候，傳入第二個參數是一個拼接後的字符串
    是先把字符串拼接好，而後再調用log方法
    log方法中的日誌等級不是1級，那麼就不會是如此拼接後的字符串
    這裏的字符串就白拼接了，形成浪費
*/
public class LoggerTest{
    public static void log(int level, String msg){
        if(level == 1){
            System.out.println(msg);
        }
    }
    public static void main(String[] args){
        String str1 = "hello";
        String str2 = "java";
        log(1, str1 + str2);
    }
}
體驗Lambda的更優寫法
/*
    使用Lambda優化日誌：
        延遲加載
    使用前提：必須存在函數式接口
    使用Lambda表達式做爲參數傳遞，僅僅是把參數傳遞到log方法中，
    只有知足條件，日誌的等級是1級
        纔會調用接口LambdaInterface方法中的msgAdd()方法
        而後進行方法的拼接
    若是條件不知足，那麼接口LambdaInterface方法中的msgAdd()方法不會執行
        拼接字符串的代碼也不會執行，不會存在性能的浪費
*/
public class LoggerTest{
    public static void log(int level, LambdaInterface li){
        if(level == 1){
            String str = li.msgAdd();
            System.out.println(str);
        }
    }
    public static void main(String[] args){
        String str1 = "hello";
        String str2 = "java";
        log(1, () -> {
            //返回一個拼接好的字符串
            return str1 + str2;
        });
    }
}
@FunctionalInterface
interface LambdaInterface{
    //定義一個拼接消息的方法，返回拼接的消息
    String msgAdd();
}
證實Lambda的延遲
public static void main(String[] args){
        String str1 = "hello";
        String str2 = "java";
        log(1, () -> {
            //沒有知足條件這裏不會執行
            System.out.println("不知足條件");
            //返回一個拼接好的字符串
            return str1 + str2;
        });
    }
使用Lambda做爲參數和返回值

Java的Lambda表達式能夠被當作匿名內部類的替代品，若是方法的參數是一個函數式接口類型，那麼就可使用Lambda表達式進行替代。使用Lambda表達式做爲方法參數，其實就是使用函數式接口做爲方法參數。
例如：Runnable接口就是一個函數式接口this

public class Demo{
    private static void startThread(Runnable runab){
        new Thread(runab).start();
    }
    public static void main(String[] args){
        startThread(() -> System.out.println(...));
    }
}
public  class DemoComparator{
    //返回值類型是一個函數式接口
    //Comparator只有一個抽象方法，因此是函數式接口
    private static Comparator<String> newComparator(){
        return (a, b) -> b.length() - a.length();
    }
    public static void main(String[] args){
        String[] arr = {"a", "abs", "dfae"};
        //排序
        Arrays.sort(arr, newComparator());
    }
}

若是返回值類型是一個函數式接口，就能夠直接返回一個Lambda表達式,如上程序。

注：Comparator有兩個抽象方法，int cimpare(T o1, T o2)和boolean equals(Object obj),若是接口聲明瞭一個覆蓋java.lang.Object的全局方法之一的抽象方法，那麼它不會計入接口的抽象方法數量中，由於接口的任何實現都將具備java.lang.Object或其餘地方的實現。

經常使用的函數式接口

Supplier接口

java.util.function.Supplier 接口包含一個無參的方法：T get();用來獲取一個泛型參數指定類型的對象。 

import java.util.function.Supplier;
public class SupplierClass{
    public static String getString(Supplier<String> sup){
        return sup.get();
    }
    public static void main(String[] args){
        String str1 = "hello";
        String str2 = "java";
        String getStringMethod = getString(() -> str1 + str2);
        System.out.println(getStringMethod);
    }
}

Supplier 被稱爲生型接口，指定接口泛型是什麼類型，接口中的get方法就返回什麼類型。

求數組最大值練習
import java.util.function.Supplier;
public class SupplierClass{
    //返回的是Integer類型
    public static Integer getMax(Supplier<Integer> sup){
        return sup.get();
    }
    public static void main(String[] args){
        int[] iArr = {12, 252, -12, 435};
        int getMaxInteger = getMax(() -> {
            int max = iArr[0];
            //遍歷數組
            for(int i : iArr){
                //若是數組有一個值大於max，則把這個值賦值給max
                if(i > max){
                    max = i;
                }
            }
            //返回數組中的最大值
            return max;
        });
        System.out.println(getMaxInteger);
    }
}
Consumer接口

java.util.function.Consumer 接口消費一個數據，而不是生產一個數據，其數據類型由泛型指定。包含抽象方法accept(T t) 

import java.util.function.Consumer;
public class ConsumerClass{
    public static void consumerUseMethod(Consumer<String> com){
        con.accept("被使用的字符串");
    }
    public static void main(String[] args){
        consumerUseMethod((x) -> System.out.println(x));
    }
}
抽象方法：Accept
import java.util.function.Consumer;
public class ConsumerClass{
    public static void consumerUseMethod(String name,Consumer<String> con){
        con.accept(name);
    }
    public static void main(String[] args){
        consumerUseMethod("lilei", (x) -> System.out.println(x));
    }
}
抽象默認方法：andThen

若是一個方法的參數和返回值全是Consumer類型，就能夠實現這個效果：消費數據的時候，首先作一個操做，而後再作一個操做，實現組合。而這個方法就是Consumer接口中default方法antThen：

default Consumer<T> andThen(Consumer<? super T> after){
    Objects.requireNonNull(after);
    return (T t) -> {
        accept(t);
        after.accept(t);
        };
}

java.util.Objects和requireNonNull靜態方法將會在參數爲null時主動拋出異常。省去重寫if語句和拋出空指針異常的麻煩。

import java.util.function.Consumer;
/*
    Consumer接口默認方法andThen
    做用：須要兩個Consumer接口，能夠把兩個Consumer接口組合到一塊兒，對數據進行消費
    
    例如：
    Consumer<String> con1
    Consumer<String> con2
    String s = 「hello」;
    con1.accept(s);
    con2.accept(s);
    鏈接兩個Consumer接口，再進行消費
    con1.andThen(con2).accept(s);
*/
public class ConsumerClass{
    public static void consumerUseMethod(String name,
                    Consumer<String> con, Consumer<String> con2){
        //con.accept(name);
        //con2.accept(name);
        //使用andThen方法替代上面代碼：
        con.andThen(con2).accept(name);
        //con連接的con2，因此先執行con，再執行con2
    }
    public static void main(String[] args){
        consumerUseMethod(
            "lilei", 
            //第一個Lambda表達式
            (x) -> System.out.println(x),
            //第二個Lambda表達式
            (x) -> System.out.println("第二個Lambda表達式")
            );
    }
}

若是須要多個Consumer接口，使用andThen方法，就是con1.andThen(con2).andThen(con3)...andThen(conN).accept(t);

Predicate接口

包含一個抽象方法：boolean test(T t)，用於條件判斷場景
符合條件：返回true
不符合：返回false

import java.util.function.Predicate;

public class PredicateClass{
    public static boolean checkString(String s, Predicate<String> pre){
        //傳入要判斷的文本
        return pre.test(s);
    }
    public static void main(String[] args){
        String str = "guess how long";
        //判斷字符串長度是否大於5，並返回結果
        boolean b = checkString(str, (String s) -> {return str.length() > 5;});
        System.out.println(b);
    }
}

省略一些代碼

//省略String s 中類型，能夠直接推導
        //只有一行語句，省略大括號和return關鍵字
        boolean b = checkString(str, s-> str.length() > 5);
默認方法and(與)

將兩個Predicate條件使用與邏輯鏈接起來實現而且的效果，使用默認方法and

default Predicate<T> and(Predicate<? super T> other){
    Objects.requireNonNull(other);
    return (t) -> test(t) && other.test(t);
}

實現：

import java.util.function.Predicate;

public class PredicateClass{
    public static void checkString(String str, Predicate<String> preOne, Predicate<String> preTwo){
        //preOne.test("str")&&preTwo.test("str");
        boolean b = preOne.and(preTwo).test(str);
        System.out.println(b);
    }
    public static void main(String[] args){
        String strName = "helloworld";
        checkString(strName, s-> s.contains("H"),s-> s.contains("W"));
    }
}
默認方法or(或)
default Predicate<T> or(Predicate<? super T> other){
    Objects.requireNonNull(Other);
    return (t) -> test(t) || other.test(t);
}

實現：

import java.util.function.Predicate;

public class PredicateClass{
    public static boolean checkString(String str, Predicate<String> preOne, Predicate<String> preTwo){
        //等價於preOne.test(t) || preTwo.test(t);
        return preOne.or(preTwo).test(str);
    }
    public static void main(String[] args){
        String strName = "helloworld";
        boolean b = checkString(strName, s-> s.contains("h"),s-> s.contains("W"));
        System.out.println(b);
    }
}
默認方法negate(非)
default Predicate<T> negate(){
    retuan (t) -> !test(t);
}
//取反
        return preOne.negate(preTwo).test(str);
Function接口

用來根據一個類型的數據獲得另外一個類型的數據，前者稱爲前置條件，後者稱爲後置條件。

抽象方法apply

Function最主要的抽象方法爲：R apply(T t)，根據類型T的參數獲取類型R的結果。

import java.util.function.Function;
public class FunctionClass{
    //Function<原始類型， 要轉換的類型>
    public static void applyMethod(String str, Function<String, Integer> fun){
        //字符串類型轉換成int類型
        int num = fun.apply(str);
        System.out.println(num + 20);
    }
    public static void main(String[] args){
        String str = "100";
        applyMethod(str, s -> Integer.parseInt(s));
    }
}
默認方法andThen
//用來組合操做
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after){
    Objects.requireNonNull(after);
    return (T t) -> after.apply(apply(t));
}

實現代碼：

import java.util.function.Function;
public class FunctionClass{
    //andThen組合操做
    public static void applyMethod(String str, Function<String, Integer> funOne, Function<Integer, String> funTwo){
        //字符串類型轉換成int類型,加10
        //int num = fun.apply(str) + 10;
        //而後轉換成String類型
        //String str = funTwo.apply(num);
        
        //組合,先實現funOne，再實現funTwo
        String strr = funOne.andThen(funTwo).apply(str);
        System.out.println(strr);
    }
    public static void main(String[] args){
        String str = "100";
        //先把字符串轉換爲integer,結果加10
        //把前面funOne的結果轉換成String類型
        applyMethod(str, (String s) -> Integer.parseInt(s) + 10, (Integer in) -> String.valueOf(in));
    }
}

Lambda方法引用

方法引用符號

雙冒號::是爲引用運算符，而它所在的表達式被稱爲方法引用。若是Lambda要表達是函數方案已經存在於某個方法的實現中，那麼則能夠經過雙冒號來引用該方法做爲Lambda的替代者。

語義分析

例如：System.out對象中有一個重載的println(String)方法剛好就是咱們所須要的，那麼對於該方法的函數式接口參數，如下兩種方式等價：

Lambda表達式： s -> System.out.println(s);
方法引用寫法： System.out::println

第一種語義是：拿到參數以後經Lambda手，繼而傳遞給System.out.println方法去處理;
第二種是：直接讓System.out中的println方法來取代Lambda。

兩種寫法的執行效果徹底同樣。而第二種方法引用複用了已有方案，更加簡潔。

Lambda中傳遞的參數必定是方法引用中那個方法能夠接收的類型，不然拋出異常。

推導與省略

若是使用Lambda，那麼根據可推導就是可省略的原則，無需指定參數類型，也無需指定重載形式--它們都是自動推導，而若是使用方法引用，也是一樣能夠根據上下文進行推導。
函數式接口是Lambda的基礎，而方法引用是Lambda的孿生兄弟。

經過對象名引用成員方法
/*
    經過對象名引用成員方法
    使用前提：對象名已經存在，成員方法已經存在
*/

public class LambdaObjectUseMethod{
    //定義一個方法
    public static void printString(Printable p){
        p.print("hello");
    }
    public static void main(String[] args){
        //Lambda表達式
        printString(x -> {
            MethodUpper mu = new MethodUpper();
            mu.printUpperCaseString(x);
        });
        
        //方法引用
        //對象必須已經存在
        MethodUpper mu2 = new MethodUpper();
        printString(mu2::printUpperCaseString);
    }
}

//函數式接口
@FunctionalInterface
interface Printable{
    void print(String s);
}



//將字符串全改成大寫並輸出
class MethodUpper{
    public void printUpperCaseString(String str){
        System.out.println(str.toUpperCase());
    }
}
經過類名稱引用靜態方法
/*
    經過對象名引用成員方法
    使用前提：類已經存在，靜態方法已經存在
*/

public class LambdaObjectUseMethod{
    //定義一個方法
    public static void printString(Printable p){
        p.print("hello");
    }
    public static void main(String[] args){
        //經過類名引用靜態方法
        printString(MethodUpper::printUpperCaseString);
    }
}

//函數式接口
@FunctionalInterface
interface Printable{
    void print(String s);
}



//將字符串全改成大寫並輸出
class MethodUpper{
    //靜態方法
    public static void printUpperCaseString(String str){
        System.out.println(str.toUpperCase());
    }
}
經過super引用成員方法
//函數式接口
@FunctionalInterface
interface Greetable{
    void greet();
}

//父類
class FatherClass{
    public void showMethod(){
        System.out.println("我是你爸爸");
    }
}

public class SonClass extends FatherClass{
    public void showMethod(){
        System.out.println("不符solo！！！");
    }
    
    public void useGreetable(Greetable gt){
        gt.greet();
    }
    public void show(){
        /*
        useGreetable(() -> {
            FatherClass fc = new SonClass();
            super.showMethod();
        });
        */
        //super引用成員方法
        useGreetable(super::showMethod);
    }
    
    public static void main(String[] args){
        new SonClass().show();
    }
}
經過this引用成員方法
//函數式接口
@FunctionalInterface
interface Greetable{
    void greet();
}

//父類
class FatherClass{
    public void showMethod(){
        System.out.println("我是你爸爸");
    }
}

public class SonClass extends FatherClass{
    public void showMethod(){
        System.out.println("不符solo！！！");
    }
    
    public void useGreetable(Greetable gt){
        gt.greet();
    }
    public void show(){
        //this引用本類成員方法
        useGreetable(this::showMethod);
    }
    
    public static void main(String[] args){
        new SonClass().show();
    }
}
類構造器的引用

構造器引用使用 類名稱::new 的格式

//類構造器引用
class Person{
    String name;
    public Person(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
}

@FunctionalInterface
interface CreatePerson{
    Person returnPerson(String name);
}

public class PersonFunctionClass{
    public static void method(String name, CreatePerson cp){
        Person p = cp.returnPerson(name);
        //Person p = 
        System.out.println(p.getName());
    }
    public static void main(String[] args){
        /*Lambda表達式
        method("lilei",(String name) -> {
            return new Person(name);
        });
        */
        
        /*簡化版的Lambda表達式
        method("lilei", name -> new Person(name));
        */
        
        //構造器引用
        method("lilei", Person::new);
    }
}
數組構造器的引用
//數組的構造器引用
@FunctionalInterface
interface ArrayBuiler{
    //建立int數組類型的方法
    int[] createIntArray(int length);
}

//數組的構造器引用
public class ArrayTestClass{
    //定義一個方法，方法參數傳遞建立數組的長度和ArrayBuiler接口
    //方法內部根據傳遞的長度建立數組
    public static int[] createArray(int length, ArrayBuiler ab){
        return ab.createIntArray(length);
    }
    
    public static void main(String[] args){
        int[] arr1 = createArray(10, (int i) -> {
            return new int[i];
        });
        
        int[] arr2 = createArray(12, len -> new int[len]);
        
        //引用數組的構造器
        int[] arr3 = createArray(13, int[]::new);
    }
}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程