java 的lambda表達式

 

爲何使用 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();
	}

}