Java Lambda表達式與函數式接口

Lambda表達式

1.什么是Lambda表達式：

簡潔的表示可以傳遞的匿名函數的一種方式。

沒有名稱，但是有參數列表，函數主體，返回類型。

2.Lambda表達式的特性：

1. 匿名：和普通方法不一樣，沒有一個明確的名字；
2. 函數：Lambda表達式不屬於任何一個類；
3. 傳遞：Lambda表達式可以作為參數（傳遞給方法，賦值給變量）；
4. 簡潔：不需要像內部類那樣，需要寫很多的模板代碼。

3.Lambda表達式由三部分構成：

1. 參數列表；
2. 箭頭：參數列表和后面的代碼塊的連接符；
3. Lambda的主體。

4.Lambda表達式的兩種寫法：

1. （參數列表）-> 代碼 （默認會有一個return ,代碼段的結尾不需要寫分號）
2. （參數列表）-> {代碼段;}（代碼段的結尾需要寫分號）

參數的類型既可以明確聲明，也可以根據上下文來推斷: (int a)與(a)

當只有一個參數，且其類型可推導時，圓括號（）可省略。例如：a -> return a*a

總結：4個特性，3個部分，2種寫法

Lambda表達式案例：

1. （String s）-> s.length()
2. (Apple a) -> a.getWeight() > 150
3. (int x , int y) -> { System.out.println("");}
4. ()->42
5. () -> "helloworld"

測驗：下面哪些不是lambda表達式

	（1） 
			()->{}  
	 (2)
			() -> "haha"
	 (3)
			() ->{return "haha";}
	 (4)
			(Integer i) -> return i ;  
	 (5)
			(String s) -> { s }

答案：（4）（5）， （1）是：Runnable()接口中的 void run()

函數式接口：

1.在哪里可以用lambda表達式呢？

在有函數式接口的地方可以使用lambda

2.什么是函數式接口？

大多數的場景下，只有一個抽象方法的接口是函數式接口

//Supplier就是一個函數式接口
public interface Supplier<T> {
    T get();
} 
//自定義了一個方法，參數是個接口
public static void f3(Supplier<String> supplier){
    System.out.println(supplier.get());
}

使用匿名內部類實例化函數式接口的對象：

f3(new Supplier<String>() {
	
	@Override
	public String get() {
		
		return "helloworld";
	}
});     //模板代碼多，有用的就一句return

采用lambda表達式：

f3(
    ()->"helloworld"      //String get()
);

測驗：下面哪些不是函數式接口？

(1)
	public interface Adder{
		int add(int a ,int b);
	}
(2)
	public interface sAdder extends Adder{
		int add(double a ,double b);
	}
(3)
	public interface Nothing{}

答案：(2)(3) (2里有兩個方法，沒有重寫)

lambda與函數式接口：

@Test
public void test4(){

    //lambda表達式  可以看成一個實現了run方法的一個實例對象
    Runnable r2 = () -> System.out.println("hellowrold - r2");

    //匿名內部類 實例對象
    Runnable r1 = new Runnable() {
        @Override
        public void run() {
            System.out.println("hello world");
        }
    };
    // public Thread(Runnable target)  //函數式接口
    // public abstract void run();   // 參數類型
    new Thread(r1).start();
    new Thread(r2).start();
}

@FunctionalInterface注解：聲明一個接口是一個函數式接口

記憶：加注解的接口里只能有一個“有效”的抽象方法。

網上有很多關於函數式接口的解釋嚴格意義上都不正確，這里糾正下：

函數式接口里面可以有多個抽象方法：編譯檢查的時候Object抽象方法不會做考慮的。

//有多個抽象方法的函數式接口，下面這個是可以的
@FunctionalInterface
public interface BufferedReaderProcessor{
    String process(BufferedReader br);
    int hashCode();
    boolean equals(Object var1);
}

//用lambda表達式實例化對象
public void test1() {
    /**
     * 受檢異常
     * 1.throws
     * 2.try catch
     */
    BufferedReaderProcessor brf = (BufferedReader br)->br.readLine(); //需要拋出個異常，需要在接口中定義的方法后面拋出
}
@FunctionalInterface
public interface BufferedReaderProcessor{
    String process(BufferedReader br) throws IOException;
    int hashCode();
    boolean equals(Object var1);
}