java Lambda 運算式

Lambda 介紹

Lambda 運算式，也可稱為閉包，他是推動 java8 發布的重要特征，
Lambda 允許把函式作為一個方法引數（函式作為引數傳遞進方法），
使用 Lambda 運算式可以是代碼更簡潔緊湊，

基礎語法

1. ( 引數 ) -> 方法體
2. ( 引數 ) -> { 方法體; };

重要特征

• 可選型別宣告： 不需要申明引數型別，編譯器統一識別引數值

a -> a + 1; 

• 可選的引數圓括號： 一個引數可以省略圓括號，但多個引數不能省略圓括號

a -> a + 1; //一個引數
(int a,int b) -> a - b; //多個引數
//根據可選型別宣告，多個引數可以省略為
(a,b) -> a + b;

• 可選的大括號： 如果方法體只有一個陳述句，可以省略大括號

a -> a+1；  

• 可選的回傳關鍵字： 如果主體只有一個運算式回傳值則編譯器會自動回傳值，大括號需要指定明運算式回傳了一個數值，

//接收一個String，直接在控制臺輸出，無回傳值
(String s) -> System.out.print(s);
// 接收一個String，回傳String
(String s) -> { return s; }

代碼示例

package test;

public  class Test{
	public static void main(String args[]){
		Test tester = new Test();
		/**
		 *  定義具體計算
		 */
	      // 型別宣告
	      MathOperation addition = (int a, int b) -> a + b;
	        
	      // 不用型別宣告
	      MathOperation subtraction = (a, b) -> a - b;
	        
	      // 大括號中的回傳陳述句
	      MathOperation multiplication = (int a, int b) -> { return a * b; };
	        
	      // 沒有大括號及回傳陳述句
	      MathOperation division = (int a, int b) -> a / b;
	        
	      System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
	      System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
	      System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
	      System.out.println("10 / 5 = " + tester.operate(10, 5, division));
	        
	      
	      // 不用括號
	      GreetingService greetService1 = message ->
	      System.out.println("Hello " + message);
	      greetService1.sayMessage("Runoob");
	        
	      // 用括號
	      GreetingService greetService2 = (message) ->
	      System.out.println("Hello " + message);
	      greetService2.sayMessage("Google");
	   }
	    
	   //數字計算
	   interface MathOperation {
	      int operation(int a, int b);
	   }
	   //接收數字，具體進行什么計算
	   private int operate(int a, int b, MathOperation mathOperation){
	      return mathOperation.operation(a, b);
	   }
	    
	   
	   interface GreetingService {
	      void sayMessage(String message);
	   }
	   
}

輸出結果為：

10 + 5 = 15
10 - 5 = 5
10 x 5 = 50
10 / 5 = 2
Hello Runoob
Hello Google

注意

• Lambda 表達是主要是用來定義行內執行的方法型別介面，例如，一個簡單方法介面，
• Lambda 運算式免去了使用匿名方法的麻煩，

變數作用域

Lambda 表達是只能應用 final 的局外變數，也就是不能再 lambda 內部修改定義在域外的區域變數，否則編譯出錯，
代碼示例：

package csdnTest;

public class LambdaTest2 {
	final static int number_1=3;
	final static int number_2=2;
	
	public static void main(String[] args) {
		Num num = (a,b) -> a+b;
		
		System.out.println(num.addNum(number_1, number_2));
		//結果為5
	}
	
	interface Num{
		int addNum(int a,int b); 
	}
}

我們也可以在 lambda 運算式中訪問外層變數

package csdnTest;

public class LambdaTest2 {
//	final static int number_1=3;
//	final static int number_2=2;
	
	public static void main(String[] args) {
		
		final int number_1=2;
		final int number_2=3;
		
		Num num = (a,b) -> a+b;
		
		System.out.println(num.addNum(number_1, number_2));
		//結果為5
	}
	
	interface Num{
		int addNum(int a,int b); 
	}
}

lambda 運算式的變數可以不用 final ，但是必須不可被后邊的代碼修改

package csdnTest;

public class LambdaTest2 {
	public static void main(String[] args) {
		
		int number_1=2;
		
		Num num = a ->number_1 = 5;//這里報錯：Local variable number_1 defined in an enclosing scope must be final or effectively final
	
		System.out.println(num.addNum(number_1));
	}
	
	interface Num{
		int addNum(int a); 
	}
}

在 Lambda 運算式中不允許宣告一個和變數同名的引數

package csdnTest;

public class LambdaTest2 {
	public static void main(String[] args) {
		
		int a=2;
		
		Num num = a ->a;//報錯：Lambda expression's parameter a cannot redeclare another local variable defined in an enclosing scope. 
		
		System.out.println(num.addNum(a));
	}
	
	interface Num{
		int addNum(int a); 
	}
}

實體 forEach 遍歷集合

實體對像

package csdnTest;

public class LambdaPerson {	
	private String name;
	private String sex;
	private int age;
}

forEach 遍歷

package csdnTest;

import java.util.ArrayList;
import java.util.List;

public class LambdaTest2{
	public static void main(String[] args) {
		List<LambdaPerson> list = getPersonList();
        list.forEach(LambdaPerson -> System.out.println(LambdaPerson.toString()));
	}
	private static List<LambdaPerson> getPersonList(){
		LambdaPerson p1 = new LambdaPerson("張三","男",22);
		LambdaPerson p2 = new LambdaPerson("李四","男",21);
		LambdaPerson p3 = new LambdaPerson("趙麗","女",21);
		LambdaPerson p4 = new LambdaPerson("王五","男",21);
        List<LambdaPerson> list = new ArrayList<LambdaPerson>();
        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);
        return list;
    }
}
//結果為
LambdaPerson [name=張三, sex=男, age=22]
LambdaPerson [name=李四, sex=男, age=21]
LambdaPerson [name=趙麗, sex=女, age=21]
LambdaPerson [name=王五, sex=男, age=21]

使用Lambda運算式代替匿名內部類

	//匿名內部類
	public void runable() {
		new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名內部類進入執行緒");
            }
        }).start();
	}
	//Lambda運算式
	public void runable() {
		 new Thread(() -> System.out.println("lambda進入執行緒")).start();
	}