摘要：利用前面所述的方法，這個例子可以用方法引用改寫成下面的樣子構(gòu)造函數(shù)引用對于一個現(xiàn)有構(gòu)造函數(shù)，你可以利用它的名稱和關(guān)鍵字來創(chuàng)建它的一個引用。

函數(shù)式接口就是只定義一個抽象方法的接口，哪怕有很多默認(rèn)方法，只要接口只定義了一個抽象方法，它就仍然是一個函數(shù)式接口。

函數(shù)式接口的抽象方法的簽名稱為函數(shù)描述符。

只有在需要函數(shù)式接口的時候才可以傳遞Lambda
下哪些是使用Lambda表達(dá)式的有效方式？
(1)
execute(() -> {});
public void execute(Runnable r){ 
r.run(); 
} 
(2)
return () -> "Tricky example ;-)"; 
(3)
Predicate p = (Apple a) -> a.getWeight();
答案：只有1和2是有效的。
第一個例子有效，是因為Lambda() -> {}具有簽名() -> void，這和Runnable中的
抽象方法run的簽名相匹配。請注意，此代碼運(yùn)行后什么都不會做，因為Lambda是空的！
第二個例子也是有效的。事實上，fetch方法的返回類型是Callable。
Callable基本上就定義了一個方法，簽名是() -> String，其中T被String代替
了。因為Lambda() -> "Trickyexample;-)"的簽名是() -> String，所以在這個上下文
中可以使用Lambda。
第三個例子無效，因為Lambda表達(dá)式(Apple a) -> a.getWeight()的簽名是(Apple) -> 
Integer，這和Predicate:(Apple) -> boolean中定義的test方法的簽名不同。

這個標(biāo)注用于表示該接口會設(shè)計成一個函數(shù)式接口,@FunctionalInterface不是必需的,它就像是@Override標(biāo)注表示方法被重寫了。

它已經(jīng)簡化了代碼，因為你不需要顯式地關(guān)閉資源了.
public static String processFile() throws IOException { 
  try (BufferedReader br = 
  new BufferedReader(new FileReader("data.txt"))) { 
  return br.readLine(); 
  } 
} 

java.util.function.Predicate接口定義了一個名叫test的抽象方法，它接受泛型T對象，并返回一個boolean。

java.util.function.Consumer定義了一個名叫accept的抽象方法，它接受泛型T的對象，沒有返回（void）。

java.util.function.Function接口定義了一個叫作apply的方法，它接受一個泛型T的對象，并返回一個泛型R的對象。
eg:
@FunctionalInterface 
public interface Function{ 
 R apply(T t); 
} 
public static  List map(List list, 
 Function f) { 
 List result = new ArrayList<>(); 
 for(T s: list){ 
 result.add(f.apply(s)); 
 } 
 return result; 
} 
// [7, 2, 6] 
List l = map( 
 Arrays.asList("lambdas","in","action"), 
 (String s) -> s.length() 
 ); 

一般來說，針對專門的輸入?yún)?shù)類型的函數(shù)式接口的名稱都要加上對應(yīng)的原始類型前綴，比如DoublePredicate、IntConsumer、LongBinaryOperator、IntFunction等。Function接口還有針對輸出參數(shù)類型的變種：ToIntFunction、IntToDoubleFunction等。

請注意，任何庫中的函數(shù)式接口都不允許拋出受檢異常（checked exception）。如果你需要Lambda表達(dá)式來拋出異常，有兩種辦法：定義一個自己的函數(shù)式接口，并聲明受檢異常，或者把Lambda包在一個try/catch塊中。

Lambda表達(dá)式需要的類型稱為目標(biāo)類型。（即對應(yīng)的函數(shù)式接口）

你還可以進(jìn)一步簡化你的代碼。Java編譯器會從上下文（目標(biāo)類型）推斷出用什么函數(shù)式接
口來配合Lambda表達(dá)式，這意味著它也可以推斷出適合Lambda的簽名，因為函數(shù)描述符可以通
過目標(biāo)類型來得到。這樣做的好處在于，編譯器可以了解Lambda表達(dá)式的參數(shù)類型，這樣就可
以在Lambda語法中省去標(biāo)注參數(shù)類型。換句話說，Java編譯器會像下面這樣推斷Lambda的參數(shù)
類型：
List greenApples = 
filter(inventory, a -> "green".equals(a.getColor())); 

為三種不同類型的Lambda表達(dá)式構(gòu)建方法引用的辦法：

List str = Arrays.asList("a","b","A","B"); 
str.sort((s1, s2) -> s1.compareToIgnoreCase(s2)); 
Lambda表達(dá)式的簽名與Comparator的函數(shù)描述符兼容。利用前面所述的方法，這個例子可
以用方法引用改寫成下面的樣子：
List str = Arrays.asList("a","b","A","B"); 
str.sort(String::compareToIgnoreCase); 

對于一個現(xiàn)有構(gòu)造函數(shù)，你可以利用它的名稱和關(guān)鍵字new來創(chuàng)建它的一個引用：
ClassName::new。

構(gòu)造函數(shù)引用
要怎么樣才能對具有三個參數(shù)的構(gòu)造函數(shù)，比如Color(int, int, int)，使用構(gòu)造函數(shù)引用呢？
答案：你看，構(gòu)造函數(shù)引用的語法是ClassName::new，那么在這個例子里面就是Color::new。但是你需要與構(gòu)造函數(shù)引用的簽名匹配的函數(shù)式接口。但是語言本身并沒有提供這樣的函數(shù)式接口，你可以自己創(chuàng)建一個：
public interface TriFunction{ 
 R apply(T t, U u, V v); 
} 
現(xiàn)在你可以像下面這樣使用構(gòu)造函數(shù)引用了：
TriFunction colorFactory = Color::new; 

comparing 方法一
查看 Comparator 類內(nèi)部實現(xiàn)，還有一個 comparing 方法，實現(xiàn)如下，
   public static > Comparator comparing(
           Function keyExtractor)
   {
       Objects.requireNonNull(keyExtractor);
       return (Comparator & Serializable)
           (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
   }
其返回值是 (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2)); 一個lambda表達(dá)式，也就是一個Compator
eg：
Comparator c = Comparator.comparing(Apple::getWeight); 
comparing 方法二
   public static  Comparator comparing(
           Function keyExtractor,
           Comparator keyComparator)
   {
       Objects.requireNonNull(keyExtractor);
       Objects.requireNonNull(keyComparator);
       return (Comparator & Serializable)
           (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
                                             keyExtractor.apply(c2));
   }
和comparing 方法一不同的是 該方法多了一個參數(shù) keyComparator ，keyComparator 是創(chuàng)建一個自定義的比較器。
Collections.sort(employees, Comparator.comparing(
               Employee::getName, (s1, s2) -> {
                   return s2.compareTo(s1);
               }));

逆序
inventory.sort(comparing(Apple::getWeight).reversed()); 
比較器鏈
thenComparing方法就是做這個用的
inventory.sort(comparing(Apple::getWeight) 
.reversed().thenComparing(Apple::getCountry)); 

謂詞接口包括三個方法：negate、and和or，讓你可以重用已有的Predicate來創(chuàng)建更復(fù)
雜的謂詞。比如，你可以使用negate方法來返回一個Predicate的非，比如蘋果不是紅的：
Predicate notRedApple = redApple.negate(); 
你可能想要把兩個Lambda用and方法組合起來，比如一個蘋果既是紅色又比較重：
Predicate redAndHeavyApple = 
redApple.and(a -> a.getWeight() > 150);
你可以進(jìn)一步組合謂詞，表達(dá)要么是重（150克以上）的紅蘋果，要么是綠蘋果：
Predicate redAndHeavyAppleOrGreen = 
redApple.and(a -> a.getWeight() > 150) 
.or(a -> "green".equals(a.getColor())); 
這一點為什么很好呢？從簡單Lambda表達(dá)式出發(fā)，你可以構(gòu)建更復(fù)雜的表達(dá)式，但讀起來仍然和問題的陳述差不多！請注意，and和or方法是按照在表達(dá)式鏈中的位置，從左向右確定優(yōu)先級的。因此，a.or(b).and(c)可以看作(a || b) && c。

你還可以把Function接口所代表的Lambda表達(dá)式復(fù)合起來。Function接口為此配了andThen和compose兩個默認(rèn)方法，它們都會返回Function的一個實例。
andThen方法會返回一個函數(shù)，它先對輸入應(yīng)用一個給定函數(shù)，再對輸出應(yīng)用另一個函數(shù)；用compose方法，先把給定的函數(shù)用作compose的參>數(shù)里面給的那個函數(shù)，然后再把函數(shù)本身用于結(jié)果。