java8中的lambda表達式簡介

Posted on by

Lambda表達式類似匿名函數，簡單地說，它是沒有聲明的方法，也即沒有訪問修飾符、返回值聲明和方法名。

Lambda允許把函數作為一個方法的參數（函數作為參數傳遞進方法中）。

Lambda表達式的語法

(parameters) -> expression
或
(parameters) -> { statements; }

參數說明：

  • 可選類型聲明：不需要聲明參數類型，編譯器可以統一識別參數值。
  • 可選的參數圓括號：一個參數無需定義圓括號，但多個參數需要定義圓括號。
  • 可選的大括號：如果主體包含瞭一個語句，就不需要使用大括號。
  • 可選的返回關鍵字：如果主體隻有一個表達式返回值則編譯器會自動返回值，大括號需要指明表達式返回瞭一個數值。

舉例說明：

// 1. 不需要參數,返回值為5
() -> 5

// 2. 接收一個參數(數字類型),返回其2倍的值
x -> 2 * x

// 3. 接受2個參數(數字),並返回他們的差值
(x, y) -> x – y

// 4. 接收2個int型整數,返回他們的和
(int x, int y) -> x + y

// 5. 接受一個 string 對象,並在控制臺打印,不返回任何值(看起來像是返回void)
(String s) -> System.out.print(s)

Lambda表達式作用域

lambda表達式中可以引用任何外部的變量或者常量。但是對這些外部的變量是有要求的：它們必須是Effectively final的。

局部內部類和匿名內部類訪問的局部變量必須由final修飾，java8開始，可以不加final修飾符，由系統默認添加。java將這個功能稱為：Effectively final功能。

方法引用

指向靜態方法的方法引用

Function<String, Integer> function1 = Integer::parseInt; // 等價於下面
Function<String, Integer> function2 = (String i) -> Integer.parseInt(i);

指向任意類型實例方法的方法引用

Function<String, String> function3 = String::toLowerCase; // 等價於下面
Function<String, String> function4 = (String i) -> i.toLowerCase();

BiFunction<String, Integer, String> biFunction = (String s, Integer i) -> s.substring(i);
BiFunction<String, Integer, String> biFunction2 = String::substring;

指向現有對象的實例方法的方法引用

String str = "hello";
Supplier<Integer> supplier = () -> str.length();
Supplier<Integer> supplier2 = str::length;

Function<Integer, String> function5 = (Integer i) -> str.substring(i);
Function<Integer, String> function6 = str::substring;

構造方法引用

package com.morris.java8.lamdba;

import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

public class MethodReferenceExample {

    public static void main(String[] args) {

        // 構造函數引用
        Supplier<String> stringSupplier = () -> new String();
        Supplier<String> stringSupplier2 = String::new;

        Function<String, String> stringFunction = (String s)->new String(s);
        Function<String, String> stringFunction2 = String::new;

        BiFunction<Runnable, String, Thread> stringBiFunction = (Runnable r, String b)-> new Thread(r, b);
        BiFunction<Runnable, String, Thread> stringBiFunction2 = Thread::new;

        ThreeFunction<ThreadGroup, Runnable, String, Thread> threeFunction = (ThreadGroup g, Runnable r, String b)-> new Thread(g, r, b);
        ThreeFunction<ThreadGroup, Runnable, String, Thread> threeFunction2 = Thread::new;

    }

    interface ThreeFunction<A, B, C, D> {
        D triple(A a, B b, C c);
    }

}

lambda與匿名內部類

從表面上看到Lambda表達式似乎隻是為瞭簡化匿名內部類書寫，這看起來僅僅通過語法糖在編譯階段把所有的Lambda表達式替換成匿名內部類就可以瞭。但實際並非如此。在JVM層面，Lambda表達式和匿名內部類有著明顯的差別。

匿名內部類

匿名內部類仍然是一個類，隻是不需要程序員顯示指定類名，編譯器會自動為該類取名。

public class AnonymousClassDemo {

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("this is an Anonymous class demo");
            }
        });
    }
}

因此上面的代碼，編譯之後將會產生兩個class文件：

AnonymousClassDemo.class
AnonymousClassDemo$1.class

進一步分析主類AnonymousClassDemo.class的字節碼，可發現其創建瞭匿名內部類的對象：

$ javap -v -p AnonymousClassDemo.class
...
  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=4, locals=1, args_size=1
         0: new           #2                  // class java/lang/Thread
         3: dup
         4: new           #3                  // class AnonymousClassDemo$1 創建匿名內部類
         7: dup
         8: invokespecial #4                  // Method AnonymousClassDemo$1."<init>":()V
        11: invokespecial #5                  // Method java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
        14: pop
        15: return
      LineNumberTable:
        line 5: 0
        line 11: 15
}
SourceFile: "AnonymousClassDemo.java"
InnerClasses:
     static #3; //class AnonymousClassDemo$1

lambda表達式

Lambda表達式通過invokedynamic指令實現，不會產生新的類。

public class LambdaDemo {
    public static void main(String[] args) {
        new Thread(()-> System.out.println("this is a lambda demo"));
    }
}

上面的代碼編譯之後隻有一個class文件:

LambdaDemo.class

通過javap查看LambdaDemo.class的字節碼，我們更能看出Lambda表達式內部表示的不同。

$ javap -v -p LambdaDemo.class
...
  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=3, locals=1, args_size=1
         0: new           #2                  // class java/lang/Thread
         3: dup
         4: invokedynamic #3,  0              // InvokeDynamic #0:run:()Ljava/lang/Runnable; 使用invokedynamic指令調用
         9: invokespecial #4                  // Method java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
        12: pop
        13: return
      LineNumberTable:
        line 4: 0
        line 5: 13

  private static void lambda$main$0(); // Lambda表達式被封裝成主類的私有方法
    descriptor: ()V
    flags: ACC_PRIVATE, ACC_STATIC, ACC_SYNTHETIC
    Code:
      stack=2, locals=0, args_size=0
         0: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #6                  // String this is a lambda demo
         5: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 4: 0
}
SourceFile: "LambdaDemo.java"
InnerClasses:
     public static final #51= #50 of #54; //Lookup=class java/lang/invoke/MethodHandles$Lookup of class java/lang/invoke/MethodHandles
BootstrapMethods:
  0: #22 invokestatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
    Method arguments:
      #23 ()V
      #24 invokestatic LambdaDemo.lambda$main$0:()V
      #23 ()V

反編譯之後我們發現Lambda表達式被封裝成瞭主類的一個私有方法，並通過invokedynamic指令進行調用。

既然Lambda表達式不是內部類的簡寫，那麼Lambda內部的this引用也就跟內部類對象沒什麼關系瞭。在Lambda表達式中this的意義跟在表達式外部完全一樣。

總結

相同點:

  • 都可以直接訪問“effectively final”的局部變量（不需要加final關鍵字，但實際上是final，編譯器編譯時會自動加上），以及外部類的成員變量（包括實例變量和類變量）。

不同點:

  • 匿名內部類可以為任意接口創建實例——不管接口包含多少個抽象方法，隻要匿名內部類實現所有的抽象方法即可。但Lambda表達式隻能為函數式接口創建實例。
  • 匿名內部類可以為抽象類、甚至普通類創建實例，但Lambda表達式隻能為函數式接口創建實例。
  • 匿名內部類實現的抽象方法的方法體允許調用接口中定義的默認方法；但Lambda表達式的代碼塊不允許調用接口中定義的默認方法。

到此這篇關於java8 lambda表達式簡介的文章就介紹到這瞭,更多相關java8 lambda表達式內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：