為什麼使用 Lambda 表示式

lLambda 是一個匿名函式，我們可以把 Lambda 表示式理解為是一段可以傳遞的程式碼（將程式碼像資料一樣進行傳遞）。使用它可以寫出更簡潔、更靈活的程式碼。作為一種更緊湊的程式碼風格，使Java的語言表達能力得到了提升。

Lambda 表示式

Lambda 表示式語法

Lambda 表示式：在Java 8 語言中引入的一種新的語法元素和操作符。這個操作符為 “->” ， 該操作符被稱為 Lambda 操作符或箭頭操作符。它將 Lambda 分為兩個部分：

左側：指定了 Lambda 表示式需要的參數

右側：指定了 Lambda 體，是抽象方法的實現邏輯，也即 Lambda 表示式要執行的功能。

package day26_1;

import org.junit.Test;

//寫一個介面 B , 其中有一個抽象方法 String upper(String string);
//使用匿名內部類的方式實現這個介面, 方法中把引數裡的字串變成大寫並返回
//使用lambda表示式方式實現這個介面, 方法中把引數裡的字串變成大寫並返回
interface B {
	String upper(String string);
}


// 最常規的做法
class B2 implements B {
	@Override
	public String upper(String string) {
		return string.toUpperCase();
	}
}
/*
interface C {
	Integer max(Integer n1, Integer n2); // 取最大值
}
*/
interface C<X extends Comparable> { // X在這裡就是泛型， 表示某種型別
	X max(X n1, X n2); // 取兩個物件中的最大值
}
/*
 * 寫一個介面 C ， 定義抽象方法 Integer max(Integer n1, Integer n2);
 *在測試方法中， 使用匿名內部類物件的方式完成這個介面的實現， 並呼叫方法， 列印輸出
 *使用lambda表示式的方式來完成相同的功能 
 * */
public class LambdaExer {
	
	@Test
	public void test2() {
		C<Integer> c = new C<Integer>() {
			@Override
			public Integer max(Integer n1, Integer n2) {
				return n1 > n2 ? n1 : n2;
			}
		};
		Integer max = c.max(10, 50);
		System.out.println(max);
		
		// lambda表示式 ： 關注引數列表 -> 方法體 
		//C c2 = (Integer n1, Integer n2) -> {return n1 > n2 ? n1 : n2;};
		C<String> c2 = (n1, n2) -> n1.compareTo(n2) > 0 ? n1 : n2; // 通用性最好
		String max2 = c2.max("asfj", "ASFJ");
		System.out.println(max2);
	}
	
	@Test
	public void test1() {
		B b1 = new B2();
		String string1 = b1.upper("abcdefg");
		System.out.println(string1);
		
		// 匿名內部類
		B b2 = new B() {// 類體 
			@Override
			public String upper(String string) {
				return string.toUpperCase();
			}
		};
		String string2 = b2.upper("abcdefg");
		System.out.println(string2);
		// lambda表示式, 只關注 抽象方法引數列表 -> 方法體
		B b3 = string -> string.toUpperCase();
		String string3 = b3.upper("abcdefg");
		System.out.println(string3);
	}
}


package day26_1;

import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import org.junit.Test;

/**
 * lambda表示式 : 需要介面, 介面中必須只有一個抽象方法, 並且方法實現的方法體中只有一行語句.
 * 	語法 : 引數列表 -> 方法體 
 * lambda表示式本質上就是一個匿名內部類的物件， 並且型別只能是介面型別
 * 
 * 	主要用於代替匿名內部類物件
 */

@FunctionalInterface
interface A {
	public String test(Integer num);
	//public Integer test2(String num);
}



public class LambdaTest {
	
	@Test
	public void test3() {
		A a1 = new A() {
			@Override
			public String test(Integer num) {
				return String.valueOf(num);
			}

		};
		// 引數型別可以省略, 並且, 如果引數列表中只有一個引數時, ()也省略
		A a2 = num -> String.valueOf(num);
		String string = a2.test(200);
		System.out.println(string);
	}
	
	@Test
	public void test2() {
		List<Student> list = StudentData.getList();
		// 比較器用於完成某兩個學生物件的比較
		Comparator<Student> comparator = new Comparator<Student>() {
			// 類體相當於介面的實現子類
			@Override
			public int compare(Student s1, Student s2) {
				return (int)(s1.getScore() - s2.getScore());
			}
		};
		Collections.sort(list,comparator);
		
		for (Student student : list) {
			System.out.println(student);
		}
		
		System.out.println("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&");
		// lambda表示式來做這個事情, 要求分數降序
		// 如果我們的方法體中, 只有一行語句, 可以省略{}, 如果有return 也可以省略
		//Comparator<Student> comparator2 = (Student s1, Student s2) -> {return (int)(s2.getScore() - s1.getScore());};
		// 因為左邊的型別中已經有了泛型, 所有右面的表示式中的型別是可以推斷的, 那麼可以省略
		//Comparator<Student> comparator2 = (Student s1, Student s2) -> (int)(s2.getScore() - s1.getScore());
		Comparator<Student> comparator2 = (s1, s2) -> (int)(s2.getScore() - s1.getScore());
		Collections.sort(list, comparator2);
		
		for (Student student : list) {
			System.out.println(student);
		}
	}
	
	@Test
	public void test1() {
		Runnable r1 = new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName() + " : hello");
			}
		};
		
		new Thread(r1).start();
		
		// lambda表示式 : 省略父類或介面, 省略方法修飾符和返回值, 方法名, 只保留引數列表, 和 方法體
		// lambda表示式本質上就是一個匿名內部類的物件
		Runnable r2 = () -> System.out.println(Thread.currentThread().getName() + " : Hello2 ");
		
		new Thread(r2).start()