這一篇屬於菜鳥級博客，只是介紹了一些在Java 8中新出現的一些很有用的接口，通過一些簡單的例子加以說明，沒有深入地闡述。
函數式接口
什麼是函數式接口？
函數式接口，@FunctionalInterface，簡稱FI，簡單的說，FI就是指僅含有一個抽象方法的接口，以@Functionalnterface標注，注意⚠️，這裡的抽象方法指的是該接口自己特有的抽象方法，而不包含它從其上級繼承過來的抽象方法，例如：
@FunctionalInterface
Interface FI{
abstract judge(int a);
abstract equals();
}
上面這個接口盡管含有兩個抽象方法，但是它仍然是一個FI，因為equals抽象方法是其從超類Object中繼承的（當然這裡的“接口繼承超類Object”的說法很有爭議，但是不妨礙咱們這裡拿來理解FI這個概念），若是對於函數借口還有什麼不明白的，個人推薦一個博客：http://lucida.me/blog/java-8-lambdas-insideout-language-features/這篇博客對java8中的一些新特性講解的非常好！！
Java8中常用的全新的接口
Predicate接口
Predicate 接口只有一個參數，返回boolean類型。該接口包含多種默認方法來將Predicate組合成其他復雜的邏輯（比如：與，或，非）：
代碼如下：
Predicate<String> predicate = (s) -> s.length() > 0;
predicate.test("foo"); // true
predicate.negate().test("foo"); // false
Predicate<Boolean> nonNull = Objects::nonNull;
Predicate<Boolean> isNull = Objects::isNull;
Predicate<String> isEmpty = String::isEmpty;
Predicate<String> isNotEmpty = isEmpty.negate();
Function 接口
Function 接口有一個參數並且返回一個結果，並附帶了一些可以和其他函數組合的默認方法（compose, andThen）：
代碼如下:
Function<String, Integer> toInteger = Integer::valueOf;
Function<String, String> backToString = toInteger.andThen(String::valueOf);
backToString.apply("123"); // "123"
Supplier 接口
Supplier 接口返回一個任意范型的值，和Function接口不同的是該接口沒有任何參數
代碼如下:
Supplier<Person> personSupplier = Person::new;
personSupplier.get(); // new Person
Consumer 接口
Consumer 接口表示執行在單個參數上的操作。
代碼如下:
Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
greeter.accept(new Person("Luke", "Skywalker"));
Comparator 接口
Comparator 是老Java中的經典接口， Java 8在此之上添加了多種默認方法：
代碼如下:
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 接口
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"
Stream 接口
java.util.Stream 表示能應用在一組元素上一次執行的操作序列。Stream 操作分為中間操作或者最終操作兩種，最終操作返回一特定類型的計算結果，而中間操作返回Stream本身，這樣你就可以將多個操作依次串起來。Stream 的創建需要指定一個數據源，比如 java.util.Collection的子類，List或者Set， Map不支持。Stream的操作可以串行執行或者並行執行。
首先看看Stream是怎麼用，首先創建實例代碼的用到的數據List：
代碼如下:
List<String> stringCollection = new ArrayList<>();
stringCollection.add("ddd2");
stringCollection.add("aaa2");
stringCollection.add("bbb1");
stringCollection.add("aaa1");
stringCollection.add("bbb3");
stringCollection.add("ccc");
stringCollection.add("bbb2");
stringCollection.add("ddd1");
Java 8擴展了集合類，可以通過 Collection.stream() 或者 Collection.parallelStream() 來創建一個Stream。
Filter 過濾
過濾通過一個predicate接口來過濾並只保留符合條件的元素，該操作屬於中間操作，所以我們可以在過濾後的結果來應用其他Stream操作（比如forEach）。forEach需要一個函數來對過濾後的元素依次執行。forEach是一個最終操作，所以我們不能在forEach之後來執行其他Stream操作。
代碼如下:
stringCollection
.stream()
.filter((s) -> s.startsWith("a"))
.forEach(System.out::println);
// "aaa2", "aaa1"
Sort 排序
排序是一個中間操作，返回的是排序好後的Stream。如果你不指定一個自定義的Comparator則會使用默認排序。
代碼如下:
stringCollection
.stream()
.sorted()
.filter((s) -> s.startsWith("a"))
.forEach(System.out::println);
// "aaa1", "aaa2"
需要注意的是，排序只創建了一個排列好後的Stream，而不會影響原有的數據源，排序之後原數據stringCollection是不會被修改的：
代碼如下:
System.out.println(stringCollection);
// ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1
⚠️ 其實這也是函數式編程的一個好處：不會改變對象狀態，每次都會創建一個新對象。
Map 映射
中間操作map會將元素根據指定的Function接口來依次將元素轉成另外的對象，下面的示例展示了將字符串轉換為大寫字符串。你也可以通過map來講對象轉換成其他類型，map返回的Stream類型是根據你map傳遞進去的函數的返回值決定的。
代碼如下:
stringCollection
.stream()
.map(String::toUpperCase)
.sorted((a, b) -> b.compareTo(a))
.forEach(System.out::println);
// "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1"
Match 匹配
Stream提供了多種匹配操作，允許檢測指定的Predicate是否匹配整個Stream。所有的匹配操作都是最終操作，並返回一個boolean類型的值。
代碼如下:
boolean anyStartsWithA =
stringCollection
.stream()
.anyMatch((s) -> s.startsWith("a"));
System.out.println(anyStartsWithA); // true
boolean allStartsWithA =
stringCollection
.stream()
.allMatch((s) -> s.startsWith("a"));
System.out.println(allStartsWithA); // false
boolean noneStartsWithZ =
stringCollection
.stream()
.noneMatch((s) -> s.startsWith("z"));
System.out.println(noneStartsWithZ); // true
Count 計數
計數是一個最終操作，返回Stream中元素的個數，返回值類型是long。
代碼如下:
long startsWithB =
stringCollection
.stream()
.filter((s) -> s.startsWith("b"))
.count();
System.out.println(startsWithB); // 3
Reduce 規約
這是一個最終操作，允許通過指定的函數來講stream中的多個元素規約為一個元素，規越後的結果是通過Optional接口表示的：
代碼如下:
Optional<String> reduced =
stringCollection
.stream()
.sorted()
.reduce((s1, s2) -> s1 + "#" + s2);
reduced.ifPresent(System.out::println);
// "aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2"
並行Streams
前面提到過Stream有串行和並行兩種，串行Stream上的操作是在一個線程中依次完成，而並行Stream則是在多個線程上同時執行。
下面的例子展示了是如何通過並行Stream來提升性能：
首先我們創建一個沒有重復元素的大表：
代碼如下:
int max = 1000000;
List<String> values = new ArrayList<>(max);
for (int i = 0; i < max; i++) {
UUID uuid = UUID.randomUUID();
values.add(uuid.toString());
}
然後我們計算一下排序這個Stream要耗時多久，
串行排序：
代碼如下:
long t0 = System.nanoTime();
long count = values.stream().sorted().count();
System.out.println(count);
long t1 = System.nanoTime();
long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("sequential sort took: %d ms", millis));
// 串行耗時: 899 ms
並行排序：
代碼如下:
long t0 = System.nanoTime();
long count = values.parallelStream().sorted().count();
System.out.println(count);
long t1 = System.nanoTime();
long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("parallel sort took: %d ms", millis));
// 並行排序耗時: 472 ms
上面兩個代碼幾乎是一樣的，但是並行版的快了50%之多，唯一需要做的改動就是將stream()改為parallelStream()。
Map
前面提到過，Map類型不支持stream，不過Map提供了一些新的有用的方法來處理一些日常任務。
代碼如下:
Map<Integer, String> map = new HashMap<>();
for (int i = 0; i < 10; i++) {
map.putIfAbsent(i, "val" + i);
}
map.forEach((id, val) -> System.out.println(val));
以上代碼很容易理解， putIfAbsent 不需要我們做額外的存在性檢查，而forEach則接收一個Consumer接口來對map裡的每一個鍵值對進行操作。
下面的例子展示了map上的其他有用的函數：
代碼如下:
map.computeIfPresent(3, (num, val) -> val + num);
map.get(3); // val33
map.computeIfPresent(9, (num, val) -> null);
map.containsKey(9); // false
map.computeIfAbsent(23, num -> "val" + num);
map.containsKey(23); // true
map.computeIfAbsent(3, num -> "bam");
map.get(3); // val33
接下來展示如何在Map裡刪除一個鍵值全都匹配的項：
代碼如下：
map.remove(3, "val3");
map.get(3); // val33
map.remove(3, "val33");
map.get(3); // null
另外一個有用的方法：
代碼如下:
map.getOrDefault(42, "not found"); // not found
對Map的元素做合並也變得很容易了：
代碼如下:
map.merge(9, "val9", (value, newValue) -> value.concat(newValue));
map.get(9); // val9
map.merge(9, "concat", (value, newValue) -> value.concat(newValue));
map.get(9); // val9concat
Merge做的事情是如果鍵名不存在則插入，否則則對原鍵對應的值做合並操作並重新插入到map中。
函數式接口的出現，是Java8對於Lambda表達式的一種支持。
Lambda表達式之進化 http://www.linuxidc.com/Linux/2015-08/121630.htm
個人推薦對於這些全新的學習方法：從官方文檔出發，最好從java.util.stream裡開始看，因為這裡的大多數接口都會在流的操作中使用的到，官方文檔裡面給出了一些簡短但有效的例子，結合文檔的解釋，能很好的理解這些全新的接口。
