Lambda 表示式是如何在java的型別系統中表示的呢？每一個lambda表示式都對應一個型別，通常是介面型別。而“函式式介面”是指僅僅只包含一個抽象方法的 介面，每一個該型別的lambda表示式都會被匹配到這個抽象方法。因為 預設方法 不算抽象方法，所以你也可以給你的函式式介面新增預設方法。

       我們可以將lambda表示式當作任意只包含一個抽象方法的介面型別，確保你的介面一定達到這個要求，你只需要給你的介面新增 @FunctionalInterface 註解，編譯器如果發現你標註了這個註解的介面有多於一個抽象方法的時候會報錯的。

Predicates

Predicates are boolean-valued functions of one argument. The interface contains various default methods for composing predicates to complex logical terms (and, or, negate)

謂詞是隻有一個引數的布林型函式。這個介面包含不同的預設方法，將謂片語成複雜的邏輯組合。

public class PredicateTest {
	public static void main(String[] args) {
		Predicate<String> predicate = (s) -> s.length() > 0;

		// 檢查給定引數的謂詞
		Boolean a = predicate.test("foo"); // true
		// 邏輯上相反的謂詞
		Boolean b = predicate.negate().test("foo"); // false

		// 引用靜態方法
		Predicate<Boolean> nonNull = Objects::nonNull;
		Predicate<Boolean> isNull = Objects::isNull;

		System.out.println(nonNull.test(null)); // false
		System.out.println(isNull.test(null)); // true

		// 引用普通方法
		Predicate<String> isEmpty = String::isEmpty;
		Predicate<String> isNotEmpty = isEmpty.negate();

		System.out.println(isEmpty.test("")); // true
		System.out.println(isNotEmpty.test("")); // false
	}
}
 

Functions

Functions accept one argument and produce a result. Default methods can be used to chain multiple functions together (compose, andThen).

將Function物件應用到輸入的引數上，然後返回計算結果

public class FunctionTest {
public static void main(String[] args) {


// toInteger 稱作函式物件
// 表示一個方法，接受一個引數，產生一個結果；第一個是入參，第二個是結果
Function<String, Integer> toInteger = Integer::valueOf;


// 返回一個先執行當前函式物件apply方法再執行after函式物件apply方法的函式物件。
Function<String, String> backToString = toInteger.andThen(String::valueOf);


backToString.apply("123"); // "123"


// 這個函式式介面的函式方法是apply, 把函式應用在指定的引數上
// 如果你想把接受一些輸入引數並將對輸入引數處理過後的結果返回的功能封裝到一個方法內，Function介面是一個不錯的選擇
System.out.println(toInteger.apply("123"));

Function<String, Integer> f1 = (t) -> Integer.valueOf(t) * 10;  
System.out.println(f1.apply("3")); // 30 

// 返回自身
System.out.println(Function.identity().apply("3"));   // 3

// 先執行 apply 在執行andThen
System.out.println(f1.andThen((r) -> String.valueOf(r) + ".....").apply("4"));  // 40..... 

// 先執行compose裡面的函式 再執行本函式的apply
System.out.println(f1.compose((String r) -> r.substring(1)).apply("a5"));  
}
}
 

Suppliers

Suppliers produce a result of a given generic type. Unlike Functions, Suppliers don't accept arguments.

public class SupplierTest {
	public static void main(String[] args) {
		Supplier<Person> personSupplier = Person::new;
		Person persion = personSupplier.get(); // new Person
		System.out.println(persion); // Person [firstName=null, lastName=null]
	}
}

Consumers

Consumers represents operations to be performed on a single input argument.

consumer 表示作用在一個入參上的操作，沒有返回值。例子 （星球大戰）

public class ConsumerTest {
	public static void main(String[] args) {
		Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
		greeter.accept(new Person("Luke", "Skywalker"));
	}
}

Comparators

Comparators are well known from older versions of Java. Java 8 adds various default methods to the interface.

public class ComparatorTest {
	public static void test() {
		List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");

		Collections.sort(names, new Comparator<String>() {
			@Override
			public int compare(String a, String b) {
				return b.compareTo(a);
			}
		});

		Collections.sort(names, (String a, String b) -> {
			return b.compareTo(a);
		});

		Collections.sort(names, (String a, String b) -> b.compareTo(a));

		Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);

		Person p1 = new Person("John", "Doe");
		Person p2 = new Person("Alice", "Wonderland");

		comparator.compare(p1, p2); // > 0
		comparator.reversed().compare(p1, p2); // < 0
	}
}

Optional 不是函式是介面，這是個用來防止NullPointerException異常的輔助型別，這是下一屆中將要用到的重要概念，現在先簡單的看看這個介面能幹什麼：

Optional 被定義為一個簡單的容器，其值可能是null或者不是null。在Java 8之前一般某個函式應該返回非空物件但是偶爾卻可能返回了null，而在Java 8中，不推薦你返回null而是返回Optional。

Optional<String> optional = Optional.of("bam");

optional.isPresent();           // true
optional.get();                 // "bam"
optional.orElse("fallback");    // "bam"

optional.ifPresent((s) -> System.out.println(s.charAt(0)));     // "b"