JDK 8的新特性-Lambda表達式 精品文章總結

一. 前言

JDK8已經發布快4年的時間了，現在來談它的新特性顯得略微的有點“不合時宜”。儘管JDK8已不再“新”，但它的重要特性之一——Lambda表達式依然是不被大部分開發者所熟練運用，甚至不被開發者所熟知。
　　國內的開發環境大家都知道，有各種的老項目，有各種各樣的發佈風險，讓公司以及項目組對新的技術往往望而卻步，有公司甚至時至今日還在使用JDK6來進行項目開發，這導致了在很多技術的選擇上受到了很大限制，進而不能跟隨時代的腳步使得項目甚至公司一步一步走向衰落。
　　本文簡單認識JDK8的重要新特性之一——Lambda表達式。 在JDK8之前，Java是不支持函數式編程的，所謂的函數編程，即可理解是將一個函數（也稱爲“行爲”）作爲一個參數進行傳遞。通常我們提及得更多的是面向對象編程，面向對象編程是對數據的抽象（各種各樣的POJO類），而函數式編程則是對行爲的抽象（將行爲作爲一個參數進行傳遞）。在JavaScript中這是很常見的一個語法特性，但在Java中將一個函數作爲參數傳遞這卻行不通，好在JDK8的出現打破了Java的這一限制。

1.2 認識Lambda表達式

    @Test
    public void test01(){
        // JDK 1.8之前用法
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("JDK 8之前用法");
            }
        };
        r1.run();

        // Lambda表達式用法
        Runnable r2 = ()->System.out.println("JDK 8 用法--Lambda表達式用法");
        r2.run();
    }

說明:

1. 在這個例子中,傳統的語法規則,我們是講一個匿名內部內作爲參數進行傳遞,我們實現了Runnable接口,並且將其作爲參數傳遞給Thread類. 實際上我們傳遞的是一段代碼, 即 我們將代碼作爲數據進行傳遞,這就帶來了需要不必要的"樣板代碼"
2. Lambda表達式一共分爲三個部分:
   1. 左邊: 代表參數列表
   2. 右邊:表示Lambda體
   3. ‘->’ 箭頭操作符

二. Lambda 表達式的格式

2.1 語法格式一: 無參數,無返回值,Lambda體只有一條語句

()->System.out.println(“hello Lambda!”);

 	 /**
     * 語法格式一: 無參數,無返回值
     */
    @Test
    public void test01(){
        int num = 0 ; // JDK 1.7 前, 必須是final
        Runnable r  = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello world! "+ num);
            }
        };
        r.run();

        System.out.println("-----------------------");
        Runnable r1 = ()->System.out.println("hello World");
        System.out.println(r1);
    }

2.2 語法格式二: 有一個參數,並且無返回值

(x)->System.out.println(x);
只有一個參數時,小括號"()" 可以省略

    /**
     * 語法格式二: 有一個參數,無返回值
     */
    @Test
    public void test02(){
        Consumer<String> con = (x)->System.out.println(x);
        con.accept("hello Consumer");
        
         System.out.println("-----------------------");
        Consumer<String> con1 = x->System.out.println(x);
        con1.accept("hello Consumer");
    }

2.3 語法格式三: 有兩個以上的參數,並且有返回值,並且Lambda體有多條語句

1. 兩個以上的參數,左側的"小括號()" 不能省略
2. Lambda 體有多條語句是,{} 不能省略
3. Lambda 體存在多條語句是return不能省略

    /**
     * 語法格式四: 有兩個以上的參數,有返回值,並且Lambda體有多條語句時
     *  大括號"{}" 不可以省略,並且參數的小括號"()"也不能省略
     */
    @Test
    public void test04(){
        Comparator<Integer> com = (x,y)->{
            System.out.println("函數式接口");
            return x.compareTo(y);
        };
        int compare = com.compare(3, 4);
        System.out.println(compare);
    }

2.4 若Lambda體中只有一條語句,return和大括號{}都可以省略

2.5 Lambda表達式的參數列表數據類型可以省略不寫,因爲JVM編譯器通過上下文推斷出,數據類型,即:“類型推斷”

(Integer x, Integer y) -> Integer.compare(x, y);

總結:
上聯：左右遇一括號省
下聯：左側推斷類型省
橫批：能省則省

三. 函數式接口

3.1 什麼是函數式接口?

1. 只包含一個包含一個抽象方法的接口,稱爲函數式接口
2. 可以通過Lambda表達式來創建愛你改接口的對象.(若Lambda表達式拋出一個受檢異常,那麼該異常需要在目標接口的抽象方法上聲明).
3. 可以在任意函數式接口上使用@FunctionIntrerace註解,這樣做可以檢查他是否是一個函數式接口,同時,Javadoc也會包含一條聲明,說明這個接口是一個函數式接口

3.2 自定義的函數式接口

@FunctionInterface
public interface MyNumber{
	public double getValue();
}

// 函數式接口中使用泛型
@FunctionInterface
public interface MyFunc<T>{
	public T getValue(T t);
}

// 作爲參數傳遞Lambda表達式
public String toUpperString(MyFunc<String> mf, String str){
	return mf.getValue(str);
}

// 作爲參數傳遞給Lambda表達式:
String newStr = toUpperString(
	(str) -> str.toUpperCase(), "abcdef");
System.out.println(newStr);

/*
作爲參數傳遞Lambda表達式: 
	爲了將Lambda表達式作爲參數傳遞,接受Lambda 表達式的參數類型必須與該Lambda
	表達式兼容的函數接口的類型
*/

3.3 Java內置的四大黑心函數式接口

函數式接口	參數類型	返回類型	用途
Consumer 消費型接口	T	void	對類型爲T的對象應用操作,包含方法: void accept(T t)
Supplier 供給型接口	無	T	返回類型爲T的對象,包含方法:T get();
Function<T,R> 函數式接口	T	R	對類型爲T的對象應用操作,並返回結果. 結果是R類型的對象. 包含的方法有: R apply (T t)
Predicate 斷定型接口	T	boolean	確定類型爲T的對象是否滿足某約束,並且返回boolean值. 包含方法: boolean test(T t) ;

package com.atguigu.java8;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

import org.junit.Test;

/*
 * Java8 內置的四大核心函數式接口
 * 
 * Consumer<T> : 消費型接口
 * 		void accept(T t);
 * 
 * Supplier<T> : 供給型接口
 * 		T get(); 
 * 
 * Function<T, R> : 函數型接口
 * 		R apply(T t);
 * 
 * Predicate<T> : 斷言型接口
 * 		boolean test(T t);
 * 
 */
public class TestLambda3 {
	
	//Predicate<T> 斷言型接口：
	@Test
	public void test4(){
		List<String> list = Arrays.asList("Hello", "atguigu", "Lambda", "www", "ok");
		List<String> strList = filterStr(list, (s) -> s.length() > 3);
		
		for (String str : strList) {
			System.out.println(str);
		}
	}
	
	//需求：將滿足條件的字符串，放入集合中
	public List<String> filterStr(List<String> list, Predicate<String> pre){
		List<String> strList = new ArrayList<>();
		
		for (String str : list) {
			if(pre.test(str)){
				strList.add(str);
			}
		}
		
		return strList;
	}
	
	//Function<T, R> 函數型接口：
	@Test
	public void test3(){
		String newStr = strHandler("\t\t\t 我大尚硅谷威武   ", (str) -> str.trim());
		System.out.println(newStr);
		
		String subStr = strHandler("我大尚硅谷威武", (str) -> str.substring(2, 5));
		System.out.println(subStr);
	}
	
	//需求：用於處理字符串
	public String strHandler(String str, Function<String, String> fun){
		return fun.apply(str);
	}
	
	//Supplier<T> 供給型接口 :
	@Test
	public void test2(){
		List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));
		
		for (Integer num : numList) {
			System.out.println(num);
		}
	}
	
	//需求：產生指定個數的整數，並放入集合中
	public List<Integer> getNumList(int num, Supplier<Integer> sup){
		List<Integer> list = new ArrayList<>();
		
		for (int i = 0; i < num; i++) {
			Integer n = sup.get();
			list.add(n);
		}
		
		return list;
	}
	
	//Consumer<T> 消費型接口 :
	@Test
	public void test1(){
		happy(10000, (m) -> System.out.println("你們剛哥喜歡大寶劍，每次消費：" + m + "元"));
	} 
	
	public void happy(double money, Consumer<Double> con){
		con.accept(money);
	}
}

函數式接口	參數類型	返回類型	用途
BiFunction<T,U,R>	T,U	R	對類型爲T,U 參數應用操作,返回R類型的結果. 包含的方法爲: R apply(T t , U u);
UnaryOperator (Function子接口)	T	T	對類型爲T的對象進行一元運算, 並返回T類型的結果. 包含方法: T apply(T t);
BinaryOperator (BiFunction子接口)	T,T	T	對類型爲T 的對象進行二元運算,並且返回T類型的結果. 包含方法爲: T apply(T t1 , T t2) ;
BiConsumer<T,U>	T,U	void	對類型爲T,U 參數應用操作. 包含方法爲 void accept(T t,U u);
ToIntFunction	T	int	計算int值的函數
ToLongFunction	T	long	計算long值的函數
ToDoubleFunction	T	double	計算double值的函數
IntFunction	int	R	參數爲int類型的函數
LongFunction	long	R	參數爲long類型的函數
DoubleFunction	double	R	參數爲double類型的函數

四. 方法引用與構造器的引用

4.1 方法引用

1. 當要傳遞給Lambda體的操作,已經有實現的方法了,可以試用方法引用!(實現抽象方法的參數列表,必須與方法引用方法的參數列表保持一致!)
2. 方法引用: 使用操作符"::"將方法名和對象或類的名字分割開來
3. 主要有以下三種情況:
   3.1 對象::實例方法
   3.2 類::靜態方法
   3.3 類::實例方法

// 例如:
(x)->System.out.println(x);  <=>  System.out::println

// 例如:
BinaryOperator<Double> bo = (x,y)-> Math.pow(x,y);
<=>
BinaryOperator<Double> bo = Math::pow;

// 例如:
Compare((x,y)->x.equals(y),"abcdef","abcdef");
<=>
Compare(String::equals,"abcdef","abcdef");
// 注意: 當需要引入方法的第一個參數是調用對象,並且第二個參數是需要引用方法的第二個參數(或無參數)時: ClassName::methodName

4.2 構造器引用

格式: ClassName::new
與函數式接口相結合,自動與函數式接口中的方法兼容.
可以吧構造器引用賦值給定義的方法. 與構造器參數列表要與接口中抽象方法的參數列表一直!

Function<Integer,MyClass> fun = (n)->new MyClass(n);
<=>
Function<Integer,MyClass> fun = MyClass::new ;

4.3 數組引用

格式: type[] :: new

Function<Integer,Integer[]> fun = (n)->new Integer[n];
<=>
Function<Integer,Integer[]> fun = MyClass[]::new ;