lambda

浩楠要禿頂發表於2023-04-05

Lambda

前言之前在學校，老師說，最好不要使用jdk8的一些新特性....程式碼閱讀不方便。
然後我天真的以為，是新特性不好用，是新特性閱讀體驗不好，所以，我就從未使用，也從未了解。
直到參加工作，發現了同事使用新特性，跟同事交流了這個新特性的事情，才知道是大學老師怕我們糊塗，於是在假日深入研究了一下

從JDK1.8開始為了簡化使用者進行程式碼的開發，專門提供有Lambda表示式的支援，利用此操作可以實現函式式的程式設計，對於函數語言程式設計比較著名的語言有:Haskell、Scala，利用函式式的程式設計可以避免掉物件導向程式設計之中一些繁瑣的處理問題。

Lambda入門小案例：

這是我自己寫的工具方法

public static int calculateNum(IntBinaryOperator operator){
        int a = 10;
        int b = 20;
        return operator.applyAsInt(a, b);
    }

在用這個方法的時候，發現引數的型別是 IntBinaryOperator ，那麼就直接檢視原始碼

發現有個方法叫applyAsInt ，含義就是說接收 int 型別的 left、right 兩個引數，最終我要返回得是 int 型別

那麼我先用一個老式得方式來呼叫這個 calculateNum 工具方法

       //  calculateNum 原始寫法
        /*
            * IntBinaryOperator   是一個介面   在 idea 中，如果先寫常規的語法的話，此時我想要用 Lambda 的話  ，
        */
        int param = calculateNum(new IntBinaryOperator() {
            @Override
            public int applyAsInt(int left, int right) {
                return left + right;
            }
        });

這是老式得寫法了。

(小技巧:如果你使用得IDEA 那麼可以使用 Alt + enter 快速生成匿名內部類轉變為Lambda表示式或者是Lambda表示式生成匿名內部類）

那麼我使用Lambda如何寫呢？

        int params = calculateNum( ( int a,int b) -> {
            return a+b;
        });

函式式介面 Functional Interface

丟擲一個疑問：在我們書寫一段 Lambda 表示式後（比如上一章節中匿名內部類的 Lambda 表示式縮寫形式），Java 編譯器是如何進行型別推斷的，它又是怎麼知道重寫的哪個方法的？

需要說明的是，不是每個介面都可以縮寫成 Lambda 表示式。只有那些函式式介面（Functional Interface）才能縮寫成 Lambda 表示式。

那麼什麼是函式式介面（Functional Interface）呢？

所謂函式式介面（Functional Interface）就是隻包含一個抽象方法的宣告。針對該介面型別的所有 Lambda 表示式都會與這個抽象方法匹配。

注意：你可能會有疑問，Java 8 中不是允許透過 defualt 關鍵字來為介面新增預設方法嗎？那它算不算抽象方法呢？答案是：不算。因此，你可以毫無顧忌的新增預設方法，它並不違反函式式介面（Functional Interface）的定義。

總結一下：只要介面中僅僅包含一個抽象方法，我們就可以將其改寫為 Lambda 表示式。為了保證一個介面明確的被定義為一個函式式介面（Functional Interface），我們需要為該介面新增註解：@FunctionalInterface。這樣，一旦你新增了第二個抽象方法，編譯器會立刻丟擲錯誤提示。

示例程式碼：

@FunctionalInterface
interface Converter<F, T> {
    T convert(F from);
}

注意：上面的示例程式碼，即使去掉 @FunctionalInterface 也是好使的，它僅僅是一種約束而已。

Lambda錯誤示例

interface IMessage {
    public void send(String str);
    public void say();
}

public class JavaDemo {
    public static void main(String[] args) {
        IMessage i = (str) -> {
            System.out.println(str);
        };
        i.send("www.baidu.com");
    }
}

Lambda表示式的幾種格式

方法沒有引數: () -> {};
方法有引數:：(引數,…,引數) -> {};

demo

package com.yhn.Lambda;

import java.util.function.Function;
import java.util.function.IntBinaryOperator;
import java.util.function.IntConsumer;
import java.util.function.IntPredicate;
/**

    一、什麼情況下可以使用 Lambda 表示式？
        Lambda表示式如果要想使用，那麼必須要有一個重要的實現要求：SAM(Single Abstract Method),介面中只有一個抽象方法。
        以IMessage介面為例，這個介面裡面只是提供有一個send()方法，
         interface IMessage {
         public void send(String str);
         }
        除此之外沒有任何其他方法定義，所以這樣的介面就被稱為函式式介面，
        而只有函式式介面才能被Lambda表示式所使用。


    二、 Lambda 表示式的格式
        Lambda 表示式在Java語言中引入了一個運算子**“->”**，該運算子被稱為Lambda運算子或箭頭運算子。它將Lambda分為兩個部分：
        左側：指定了Lambda表示式需要的所有引數
        右側：制定了Lambda體，即Lambda表示式要執行的功能。
        方法沒有引數: () -> {};
        方法有引數:：(引數,…,引數) -> {};

        省略規則
          引數型別可以省略
          方法體只有一句程式碼時大括號return和唯一一句程式碼的分號可以省略
          方法只有一個引數時小括號可以省略
          以上這些規則都記不住也可以省略不記
 *
 */

public class LambdaDemo {

    public static void main(String[] args) {
        printNum2(value -> value % 2 == 0, value -> value>4);

        /* ------------------------------------------------------------------------------------------ */

        //  calculateNum 原始寫法
        /*
            * IntBinaryOperator   是一個介面   在 idea 中，如果先寫常規的語法的話，此時我想要用 Lambda 的話  ，
            * 可以使用 Alt + enter 快速生成匿名內部類 轉變為Lambda表示式 或者 是Lambda表示式 生成匿名內部類
        */
        int param = calculateNum(new IntBinaryOperator() {
            @Override
            public int applyAsInt(int left, int right) {
                return left + right;
            }
        });


        // 使用 Lambda 寫法
        int params = calculateNum( ( int a,int b) -> {
            return a+b;
        });

        /* ------------------------------------------------------------------------------------------ */

        /*
         *  printNum    IntPredicate 介面只有一個方法 test
         */
        printNum(new IntPredicate() {
            @Override
            public boolean test(int value) {
                return value%2==0;
            }
        });

        printNum( (int a) -> {
            return a%2 == 0;
        });

        /* ------------------------------------------------------------------------------------------ */

        // 先解釋  Function<T, R> 介面  - >  Function<String, R>
        // Function 介面 有個方法叫 apply   含義就是說   R 傳什麼型別 , 我最終都是要返回的是 T 型別  在此處是  String 型別


        //  此時 我只需要 設定一個泛型即可
        Integer result  = typeConver(new Function<String, Integer>() {

            @Override
            public Integer apply(String s) {
                return Integer.valueOf(s);
            }
        });

        Integer results  = typeConver( (String s) ->{
            return Integer.valueOf(s);
        });

        // 擴充套件
        String s1 = typeConver(s -> {
            return s + "new";
        });


        /* ------------------------------------------------------------------------------------------ */

        foreachArr(new IntConsumer() {
            @Override
            public void accept(int value) {
                System.out.println(value);
            }
        });

        foreachArr((int value ) -> {
            System.out.println(value);
        });

        // 進行省略
        foreachArr( value -> System.out.println(value));


        /* ------------------------------------------------------------------------------------------ */
    }



    public static void foreachArr(IntConsumer consumer){
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        for (int i : arr) {
            consumer.accept(i);
        }
    }




    public static <R> R typeConver(Function<String,R> function){
        String str = "1235";
        R result = function.apply(str);
        return result;
    }



    public static void printNum2(IntPredicate predicate,IntPredicate predicate2){
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        for (int i : arr) {
            if(predicate.and(predicate2).test(i)){
                System.out.println(i);
            }
        }
    }

    public static void printNum(IntPredicate predicate){
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        for (int i : arr) {
            if(predicate.test(i)){
                System.out.println(i);
            }
        }
    }

    public static int calculateNum(IntBinaryOperator operator){
        int a = 10;
        int b = 20;
        return operator.applyAsInt(a, b);
    }
}

總結：

Lambda 表示式在Java語言中引入了一個運算子“->”，該運算子被稱為Lambda運算子或箭頭運算子。它將Lambda分為兩個部分：
左側：指定了Lambda表示式需要的所有引數
右側：制定了Lambda體，即Lambda表示式要執行的功能。
方法沒有引數: () -> {};
方法有引數:：(引數,…,引數) -> {};

省略規則
引數型別可以省略
方法體只有一句程式碼時大括號return和唯一一句程式碼的分號可以省略
方法只有一個引數時小括號可以省略
以上這些規則都記不住也可以省略不記

方法引用

方法引用的三種形式

物件 :: 非靜態方法

類 :: 靜態方法

類 :: 非靜態方法

類引用靜態方法

語法格式：類名稱::static方法名稱

第一步，我們自定義一個介面，該介面中只有一個抽象方法，是一個函式式介面。

第二步，隨便建立一個類，建立一個方法。這裡要注意，建立的方法返回值型別和形參列表必須和函式式介面中的抽象方法相同。

第三步，建立函式式介面的實現類，我們可以使用方法引用。相當於實現類裡的重寫的方法，就是方法引用的方法。這樣才能方法引用。

public class LambdaDemoLei {
    /**
     *   @FunctionalInterface，主要用於編譯級錯誤檢查，加上該註解，當你寫的介面不符合函式式介面定義的時候，編譯器會報錯。
     */
    @FunctionalInterface
    interface IMessage<T,P> {
        public T transfer(P p);
    }

    static class Supplier{
        public static String getStr(Integer integer) {
            return String.valueOf(integer);
        }
    }
    public static void main(String[] args) {
    //        類引用靜態方法   類名稱::static方法名稱
        IMessage<String, Integer> msg = Supplier::getStr;
        System.out.println(msg.transfer(31415926));
    }
    
    // 輸出 31415926

物件引用非靜態方法

語法格式：例項化物件::普通方法；

有了類引用靜態方法的基礎，相信大家已經有了一點感覺。

物件引用非靜態方法，和類引用靜態方法一致。要求我們物件引用的方法，返回值和形參列表要和函式式介面中的抽象方法相同。

public class LambdaDemoLei {
    @FunctionalInterface
    interface IMessage1 {
        public double get();
    }

    static class Supplier1{
        private Double salary;

        public Supplier1() {
        }

        public Supplier1(Double salary){
            this.salary = salary;
        }
        public Double getSalary() {
            return this.salary;
        }
    }
    
        public static void main(String[] args) {
//        物件引用非靜態方法   語法格式： 例項化物件::普通方法
        Supplier1 supplier = new Supplier1(9999.9);
        IMessage1 msg1 = supplier::getSalary;
        System.out.println(msg1.get());
    }
    
    // 輸出 9999.9
}

類引用非靜態方法

語法格式：類::普通方法

類引用普通方法就有點難以理解了。

當抽象方法中有兩個引數，且第一個引數是呼叫者，第二個引數是形參，則可以使用類::例項方法。

package com.yhn.Lambda;

import lombok.Data;

/**
 * @Description
 * @Author TuiMao
 * @Date 2023/4/4 16:19
 * @Version 1.0
 */
@Data
public class Person {
    @FunctionalInterface
    interface IMessage<T, P> {
        // 要看成 T res = p1.compare(p2);
        public T compare(P p1, P p2);
    }

    @FunctionalInterface
    interface IMessage2<T, P, V> {
        //  public T create(P p1, V p2); 符合抽象方法的要求
        public T create(P p1, V p2);
    }



    @FunctionalInterface
    interface IMessage1<T, P, V> {
        // 看成 T res = p1.compare(p2);
        // public int compareTo(String anotherString){} 符合抽象方法的格式
        // int res = str1.compare(str2);
        public T compare(P p1, V p2);
    }


    public Person() {
    }

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    private String name;
    private Integer age;

    public boolean equal(Person per) {
        return this.name.equals(per.getName()) && this.age.equals(per.getAge());
    }

    public static void main(String[] args) {
        Person person1 = new Person("張三", 22);
        Person person2 = new Person("張三", 23);
        // 符合T res = p1.compare(p2);
        IMessage<Boolean, Person> msg = Person::equal;
        System.out.println(msg.compare(person1, person2));

        System.out.println("----------");

        // 類引用普通方法  語法格式： 類::普通方法       當抽象方法中有兩個引數，且第一個引數是呼叫者，第二個引數是形參，則可以使用類::例項方法。
        IMessage1<Integer,String,String> stringCompare = String::compareTo;
        Integer compare = stringCompare.compare("adc", "abd");
        System.out.println(compare);

        System.out.println("----------");

        // 構造引用  語法格式： 類名稱::new
        IMessage2<Person,String,Integer> msg1 = Person::new;
        Person person = msg1.create("張三", 20);
        System.out.println(person);

    }

}

Lambda 訪問外部變數及介面預設方法

在本章節中，我們將會討論如何在 lambda 表示式中訪問外部變數（包括：區域性變數，成員變數，靜態變數，介面的預設方法.），它與匿名內部類訪問外部變數很相似。

訪問區域性變數

在 Lambda 表示式中，我們可以訪問外部的 final 型別變數，如下面的示例程式碼：

// 轉換器
@FunctionalInterface
interface Converter<F, T> {
    T convert(F from);
}

final int num = 1;
Converter<Integer, String> stringConverter =
        (from) -> String.valueOf(from + num);

stringConverter.convert(2);     // 3

與匿名內部類不同的是，我們不必顯式宣告 num 變數為 final 型別，下面這段程式碼同樣有效：

int num = 1;
Converter<Integer, String> stringConverter =
        (from) -> String.valueOf(from + num);

stringConverter.convert(2);     // 3

但是 num 變數必須為隱式的 final 型別，何為隱式的 final 呢？就是說到編譯期為止，num 物件是不能被改變的，如下面這段程式碼，就不能被編譯透過：

int num = 1;
Converter<Integer, String> stringConverter =
        (from) -> String.valueOf(from + num);
num = 3;

在 lambda 表示式內部改變 num 值同樣編譯不透過，需要注意, 比如下面的示例程式碼：

int num = 1;
Converter<Integer, String> converter = (from) -> {
	String value = String.valueOf(from + num);
	num = 3;
	return value;
};

訪問成員變數和靜態變數

上一章節中，瞭解瞭如何在 Lambda 表示式中訪問區域性變數。與區域性變數相比，在 Lambda 表示式中對成員變數和靜態變數擁有讀寫許可權：

    @FunctionalInterface
    interface Converter<F, T> {
        T convert(F from);
    }

class Lambda4 {
        // 靜態變數
        static int outerStaticNum;
        // 成員變數
        int outerNum;

        void testScopes() {
            Converter<Integer, String> stringConverter1 = (from) -> {
                // 對成員變數賦值
                outerNum = 23;
                return String.valueOf(from);
            };

            Converter<Integer, String> stringConverter2 = (from) -> {
                // 對靜態變數賦值
                outerStaticNum = 72;
                return String.valueOf(from);
            };
        }
    }

訪問介面的預設方法

@FunctionalInterface
interface Formula {
	// 計算
	double calculate(int a);

	// 求平方根
	default double sqrt(int a) {
		return Math.sqrt(a);
	}
}

當時，我們在介面中定義了一個帶有預設實現的 sqrt 求平方根方法，在匿名內部類中我們可以很方便的訪問此方法：

Formula formula = new Formula() {
	@Override
	public double calculate(int a) {
		return sqrt(a * 100);
	}
};

但是在 lambda 表示式中可不行：

Formula formula = (a) -> sqrt(a * 100);

帶有預設實現的介面方法，是不能在 lambda 表示式中訪問的，上面這段程式碼將無法被編譯透過。

JDK8自帶函式式介面

在JDK1.8之中，提供有Lambda表示式和方法引用，但是你會發現如果由開發者自己定義函式式的介面，往往都需要使用@FunctionalInterface來進行大量的宣告，於是很多的情況下如果為了方便則可以引用系統中提供的函式式介面。

在系統之中專門提供有一個java.util.functional的開發包，裡面可以直接使用函式式介面，在這個包下面一共有如下幾個核心的介面供我們使用。

功能型函式式介面

介面定義	介面作用	介面使用
@FunctionalInterface public interface Function<T,R>	消費 T 型別引數，返回 R 型別結果	如下所示

function 相當於是給一個引數，然後返回一個結果。
如果是給兩個引數，返回一個結果，那麼就是 BiFunction。Bi 字首即使 binary 的縮寫。

import java.util.function.*;
/*
  @FunctionalInterface
  T是引數型別
  R是返回型別
  public interface Function<T,R>{
  	public R apply(T t);
  }
 */
class StringCompare {
	// 給一個 String 型別的引數，返回布林型別，符合功能性函式式介面的抽象方法
    public static boolean test(String t) {
        return t == null;
    }
}
public class JavaDemo {
    public static void main(String[] args) {
    	// 直接靜態引用
        Function<String,Boolean> func1 = StringCompare::test;
        System.out.println(func1.apply(null));
    }
}

// true

消費型函式式介面

消費性函式式介面，只能進行資料的處理操作，而沒有返回值

· 在進行系統輸出的時候使用的是:System.out.println();這個操作只是進行資料的輸出和消費，而不能返回，這就是消費性介面。

介面定義	介面作用	介面使用
@FunctionalInterface public interface Consumer	接收一個 T 型別引數，但是不返回任何東西，消費型介面	如下

其實最常見的消費型介面的實現，就是 System.out.println(xxx) 了。我們只管往方法中輸入引數，但是並沒有返回任何值。
Consumer 相當於是有來無回，給一個引數，但是無返回。
而如果是兩個引數，無返回，那麼就是 BiConsumer。

public class JavaDemo {
    public static void main(String[] args) {
        Consumer<String> consumer = System.out::println;
        consumer.accept("Hello World!");
    }
}

// Hello World!

當然我們也可以自定義消費性介面

class StringCompare {
	// 接收 StringBuilder ，但是不返回任何資料。
    public void fun(StringBuilder sb) {
        sb.append("World!");
    }
}

public class JavaDemo {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("Hello ");
        Consumer<StringBuilder> consumer = new StringCompare()::fun;
        consumer.accept(sb);
        System.out.println(sb.toString());
    }
}

供給型函式式介面

介面定義	介面作用	介面使用
@FunctionalInterface public interface Supplier	啥也不接受，但是卻返回 T 型別資料，供給型介面	如下

Supplier 相當於是無中生有，什麼也不傳，但是返回一個結果。
像 String 類裡的 toUpperCase() 方法，也是不接受引數，但是返回 String 型別，就可以看成這個供給型函式式介面的一個實現。

public String toUpperCase() {
        return toUpperCase(Locale.getDefault());
    }

import java.util.function.*;
public class Demo01 {
	public static void main(String[] args) {
		Supplier <String> sup = "WWW.BAIDU.COM" :: toLowerCase;
		System.out.println(sup.get());
	}
}

斷言型函式式介面

介面定義	介面作用	介面使用
@FunctionalInterface public interface Predicate	傳入 T 型別引數，返回布林型別，常常用於對入參進行判斷	如下

class StringFilter {
	// 對集合中的資料進行過濾，傳入斷言型介面進行判斷
    public static List<String> filter(List<String> list, Predicate<String> predicate) {
        List<String> stringList = new ArrayList<>();
        for (String str : list) {
            if (predicate.test(str)) {
                stringList.add(str);
            }
        }
        return stringList;
    }

}

public class JavaDemo {
    public static void main(String[] args) {
        List<String> stringList = Arrays.asList("好詩", "好文", "好評", "好漢", "壞蛋", "蛋清", "清風", "風間");
        List<String> filterList = StringFilter.filter(stringList, list -> list.contains("好"));
        System.out.println(filterList);
    }
}

如果JDK本身提供的函式式介面可以被我們所使用，那麼就沒必要重新去定義了。

Lambda、Linq
2024-08-08
lambda 表示式
2024-09-21
lambda表示式
2024-08-15
Java Lambda Stream
2023-05-02
Java
Java Lambda Expressions
2018-11-22
JavaExpress
lambda 函式
2018-04-03
函式
Lambda對比匿名內部類，Lambda是什麼，Lambda該怎麼用，Lambda使用過程中有什麼需要注意的？
2020-12-03
使用 Lambda Web Adapter 在 Lambda 上構建 web 應用
2023-04-07
WebAPT
在lambda的foreach遍歷中break退出(lambda foreach break)
2020-04-07
八，Lambda表示式
2024-10-18
Python Lambda 表示式
2024-06-20
Python
Java Lambda表示式
2024-06-02
Java
【Kotlin】Lambda表示式
2024-04-07
Kotlin
C# Lambda Mapper
2024-03-28
C#APP
kotlin lambda表示式
2021-08-03
Kotlin
CPP lambda表示式
2020-10-14
python map和lambda
2020-10-08
Python
Python - lambda 表示式
2021-08-11
Python
Java | Lambda表示式
2018-09-30
Java
6.lambda-matrix
2018-09-27
python-lambda用法
2018-04-18
Python
Lambda表示式（Java)
2018-04-12
Java
Java Lambda表示式應用介紹，幫助大家快速掌握Lambda
2020-09-30
Java
C# Lambda表示式詳解，及Lambda表示式樹的建立
2018-11-19
C#
C++ Lambda 表示式
2024-11-29
C++
map 和 lambda 函式
2024-11-18
函式
lambda實現遞迴
2024-08-30
遞迴
Java Lambda 使用備忘
2024-08-21
Java
Lambda Function, Callable, Optional in Python
2024-03-10
FunctionPython
lambda（持續補充）
2024-03-06
C#lambda表示式
2024-04-12
C#
cpp的lambda表示式
2024-05-08
C++Lambda表示式
2021-10-14
C++
Java基礎系列-Lambda
2020-10-22
Java
淺談lambda表示式
2020-04-06
Lambda表示式詳解
2019-06-16
Java之lambda表示式
2021-03-27
Java
AWS Lambda 使用入門
2019-03-04