一. 函數式編程

Java8所有的新特性基本基於函數式編程的思想，函數式編程的帶來，給Java註入了新鮮的活力。

下麵來近距離觀察一下函數式編程的幾個特點：

• 函數可以作為變數、參數、返回值和數據類型。
• 基於表達式來替代方法的調用
• 函數無狀態，可以併發和獨立使用
• 函數無副作用，不會修改外部的變數
• 函數結果確定性；同樣的輸入，必然會有同樣的結果。

下麵jdk1.8裡面對函數式編程的定義。只是一個  FunctionalInterface 介面。特別的簡單。

1 @Documented
2 @Retention(RetentionPolicy.RUNTIME)
3 @Target(ElementType.TYPE)
4 public @interface FunctionalInterface {}

這個函數式介面有幾點以下的限制：

• 唯一的抽象方法，有且僅有一個 (即所有的函數式介面，有且只能有一個抽象方法)
• 加上標註,則會觸發JavaCompiler的檢查。對於符合函數介面的介面，加不加都無關緊要，但是加上則會提供一層編譯檢查的保障。如果不符合，則會報錯。 
• 不能被覆蓋之後，再聲明為抽象方法，則不算抽象方法。例如介面實現了Object中的方法。 
• 可用於lambda類型的使用方式 

二. Java8新增函數式介面

Stream的操作是建立在函數式介面的組合之上的。Java8中新增的函數式介面都在java.util.function包下。這些函數式介面可以有多種分類方式。

2.1 Function

Function是從T到R的一元映射函數。將參數T傳遞給一個函數，返回R。即R = Function(T)

Function最常用的應該是  <R> Stream<R> map(Function<? super T, ? extends R> mapper);

比如List<Person> person裡面有age，name.... 我傳入age，他就會返回age的集合給我。

 1 @FunctionalInterface
 2 public interface Function<T, R> {
 3 
 4     R apply(T t);
 5 
 6     default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
 7         Objects.requireNonNull(before);
 8         return (V v) -> apply(before.apply(v));
 9     }
10 
11     default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
12         Objects.requireNonNull(after);
13         return (T t) -> after.apply(apply(t));
14     }
15 
16     static <T> Function<T, T> identity() {
17         return t -> t;
18     }
19 }

2.2 Predicate

Predicate是一個謂詞函數，主要作為一個謂詞演算推導真假值存在，返回布爾值的函數。Predicate等價於一個Function的boolean型返回值的子集。

predicate最常用的莫過於  Stream<T> filter(Predicate<? super T> predicate);  

比如我要過濾年齡 > 18 的人，我傳入age，判斷是否為true。為true則保留，false丟棄。

 1 @FunctionalInterface
 2 public interface Predicate<T> {
 3 
 4     boolean test(T t);
 5 
 6     default Predicate<T> and(Predicate<? super T> other) {
 7         Objects.requireNonNull(other);
 8         return (t) -> test(t) && other.test(t);
 9     }
10 
11     default Predicate<T> negate() {
12         return (t) -> !test(t);
13     }
14 
15     default Predicate<T> or(Predicate<? super T> other) {
16         Objects.requireNonNull(other);
17         return (t) -> test(t) || other.test(t);
18     }
19 
20     static <T> Predicate<T> isEqual(Object targetRef) {
21         return (null == targetRef)
22                 ? Objects::isNull
23                 : object -> targetRef.equals(object);
24     }
25 }

2.3 Consumer

Consumer是從T到void的一元函數，接受一個入參但不返回任何結果的操作。

Consumer最常用的肯定是   default void forEach(Consumer<? super T> action) {}

這是一段forEach迴圈的代碼，傳入實現的方法，並不返回任何值。只是迴圈。

 1 @FunctionalInterface
 2 public interface Consumer<T> {
 3 
 4     void accept(T t);
 5 
 6     default Consumer<T> andThen(Consumer<? super T> after) {
 7         Objects.requireNonNull(after);
 8         return (T t) -> { accept(t); after.accept(t); };
 9     }
10 }

三. Lambda表達式

3.1 基本語法

Lambda 的基本結構為 (arguments) -> body，有如下幾種情況：

• 參數類型可推導時，不需要指定類型，如 (a) -> System.out.println(a)
• 當只有一個參數且類型可推導時，不強制寫 (), 如 a -> System.out.println(a)
• 參數指定類型時，必須有括弧，如 (int a) -> System.out.println(a)
• 參數可以為空，如 () -> System.out.println(“hello”)
• body 需要用 {} 包含語句，當只有一條語句時 {} 可省略

3.2 Lambda原理

比如如下代碼：

 1 List<Integer> list = new ArrayList<>();
 2 
 3 list.stream().filter((x) -> x >= 18)
 4 
 5 Stream<T> filter(Predicate<? super T> predicate);
 6 
 7 @FunctionalInterface
 8 public interface Predicate<T> {
 9 
10     boolean test(T t);
11 
12 }

比如List裡面存個個人的年齡，現在篩選出年齡大於等於18的人。

此時我們就可以用  list.stream().filter((x) -> x >= 18)   這就是一個典型的lambda表達式

(x) -> x >= 18 傳給  Predicate 函數式介面。

原理其實是：

JVM幫我們動態生成了一個內部類，然後這個內部類實現了 Predicate 這個函數式介面。

重寫了裡面的test方法。生成的類似如下：

1 static final class Main$$Lambda$1 implements Predicate<Integer> {
2     private Main$$Lambda$1() {
3     }
4 
5     @Override
6     public boolean test(Integer x) {
7         return x >= 18;
8     }
9 }

3.3 Lambda用法

 1 public class Main {
 2     public static void main(String[] args) {
 3 
 4         List<Integer> list = new ArrayList<>();
 5         list.add(40);
 6         list.add(50);
 7         list.add(20);
 8         list.add(30);
 9         List<Integer> collect = list.stream().filter(x -> x >= 30)
10                 .map((x) -> x + 10).sorted((x, y) -> -x.compareTo(y))
11                 .collect(Collectors.toList());
12         System.out.println(collect);
13     }
14 }

這個一段很典型的Lambda + Stream的用法。

• list.stream()獲取list的stream的流
• filter篩選出年齡大於30的人 (裡面是一個Predicate介面，返回真假)
• map做一個function映射
• sort排序，裡面是compartor

四. 總結

Lambda 表達式可以減少很多代碼，能提高生產力。但也要理解其原理。比如3.3中的代碼，為什麼filter裡面是斷言表達式，map裡面是function表達式。

這都要從lambda的原理入手，也就是JVM動態生成一個內部類，並繼承其中的抽象方法。

本次主要介紹了Java函數式編程的原理以及應用，主要從Stream和lambda入手。通過一些簡單的概念，以及代碼，更好的理解Java的函數式編程。

掌握Java的函數式編程，對平時我們開發代碼，看其他人的代碼，都有很大的幫助。

且行且珍惜，加油！