4 - Predicate（斷言型介面）

Predicate介面只有一個引數，返回boolean型別。該介面包含多種預設方法來將Predicate組合成其他複雜的邏輯（比如：與，或，非）。Stream

的filter方法就是接受Predicate作為入參的。這個具體在後面使用Stream的時候再分析深入。原始碼及使用示例如下:

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

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();

5 - Function（功能型介面）

Function介面有一個引數並且返回一個結果，並附帶了一些可以和其他函式組合的預設方法（compose

,andThen）。原始碼及使用示例如下:

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}

Function<String, Integer> toInteger = Integer::valueOf;
Function<String, String> backToString = toInteger.andThen(String::valueOf);
backToString.apply("123");     // "123"

6 - Operator

Operator其實就是Function，函式有時候也叫作運算元。運算元在Java8中介面描述更像是函式的補充，和上面的很多型別對映型函式類似。運算元 Operator 包括：UnaryOperator和BinaryOperator。分別對應單（一）元運算元和二元運算元。

運算元的介面宣告如下：

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {
    static <T> UnaryOperator<T> identity() {
        return t -> t;
    }
}

@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T> {

    public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
    }

    public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
    }
}

Operator只需宣告一個泛型引數 T 即可。對應的使用示例如下：

UnaryOperator<Integer> increment = x -> x + 1;
System.out.println("遞增:" + increment.apply(2)); // 輸出 遞增:3

BinaryOperator<Integer> add = (x, y) -> x + y;
System.out.println("相加:" + add.apply(2, 3)); // 輸出 相加:5

BinaryOperator<Integer> min = BinaryOperator.minBy((o1, o2) -> o1 - o2);
System.out.println("最小值:" + min.apply(2, 3)); // 輸出 最小值:2

7 - 其他函式式介面

java.lang.Runnable
java.util.concurrent.Callable
java.security.PrivilegedAction
java.io.FileFilter
java.nio.file.PathMatcher
java.lang.reflect.InvocationHandler
java.beans.PropertyChangeListener
java.awt.event.ActionListener
javax.swing.event.ChangeListener

四. 方法引用

1 - 概述

在學習了 Lambda 表示式之後，我們通常使用 Lambda 表示式來建立匿名方法。然而，有時候我們僅僅是呼叫了一個已存在的方法。如下：

Arrays.sort(strArray, (s1, s2) -> s1.compareToIgnoreCase(s2));

在 Java 8 中，我們可以直接通過方法引用來簡寫 Lambda 表示式中已經存在的方法。

Arrays.sort(strArray, String::compareToIgnoreCase);

這種特性就叫做方法引用(Method Reference)。

方法引用是用來直接訪問類或者例項的已經存在的方法或者構造方法。方法引用提供了一種引用而不執行方法的方式，它需要由相容的函式式介面構成的目標型別上下文。計算時，方法引用會建立函式式介面的一個例項。當 Lambda 表示式中只是執行一個方法呼叫時，不用 Lambda 表示式，直接通過方法引用的形式可讀性更高一些。方法引用是一種更簡潔易懂的 Lambda 表示式。

注意: 方法引用是一個 Lambda 表示式，其中方法引用的操作符是雙冒號::。

2 - 分類

方法引用的標準形式是：類名::方法名。（注意：只需要寫方法名，不需要寫括號）

有以下四種形式的方法引用：

引用靜態方法: ContainingClass::staticMethodName
引用某個物件的例項方法: containingObject::instanceMethodName
引用某個型別的任意物件的例項方法:ContainingType::methodName
引用構造方法: ClassName::new

3 - 示例

使用示例如下：

public class Person {

    String name;

    LocalDate birthday;

    public Person(String name, LocalDate birthday) {
        this.name = name;
        this.birthday = birthday;
    }

    public LocalDate getBirthday() {
        return birthday;
    }

    public static int compareByAge(Person a, Person b) {
        return a.birthday.compareTo(b.birthday);
    }

    @Override
    public String toString() {
        return this.name;
    }
}

測試類：

public class MethodReferenceTest {

    @Test
    public static void main() {
        Person[] pArr = new Person[] {
            new Person("003", LocalDate.of(2016,9,1)),
            new Person("001", LocalDate.of(2016,2,1)),
            new Person("002", LocalDate.of(2016,3,1)),
            new Person("004", LocalDate.of(2016,12,1))
        };

        // 使用匿名類
        Arrays.sort(pArr, new Comparator<Person>() {
            @Override
            public int compare(Person a, Person b) {
                return a.getBirthday().compareTo(b.getBirthday());
            }
        });

        //使用lambda表示式
        Arrays.sort(pArr, (Person a, Person b) -> {
            return a.getBirthday().compareTo(b.getBirthday());
        });

        //使用方法引用，引用的是類的靜態方法
        Arrays.sort(pArr, Person::compareByAge);
    }

}

五. Stream 流操作

流是 Java8 中 API 的新成員，它允許你以宣告式的方式處理資料集合（通過查詢語句來表達，而不是臨時編寫一個實現）。這有點兒像是我們操作資料庫一樣，例如我想要查詢出熱量較低的菜品名字我就可以像下面這樣：

COPYSELECT name FROM dishes WHERE calorie < 400;

您看，我們並沒有對菜品的什麼屬性進行篩選（比如像之前使用迭代器一樣每個做判斷），我們只是表達了我們想要什麼。那麼為什麼到了 Java 的集合中，這樣做就不行了呢？

另外一點，如果我們想要處理大量的資料又該怎麼辦？是否是考慮使用多執行緒進行併發處理呢？如果是，那麼可能編寫的關於併發的程式碼比使用迭代器本身更加的複雜，而且除錯起來也會變得麻煩。

基於以上的幾點考慮，Java 設計者在 Java 8 版本中(真正把函數語言程式設計風格引入到 Java 中)，引入了流的概念，來幫助您節約時間！並且有了 Lambda 的參與，流操作的使用將更加順暢！

1 - 流操作特點

特點一：內部迭代

就現在來說，您可以把它簡單的當成一種高階的迭代器（Iterator），或者是高階的 for 迴圈，區別在於，前面兩者都是屬於外部迭代，而流採用內部迭代。

上圖簡要說明了內部迭代與外部迭代的差異，我們再舉一個生活中實際的例子（引自《Java 8 實戰》），比如您想讓您兩歲的孩子索菲亞把她的玩具都收到盒子裡面去，你們之間可能會產生如下的對話：

你：“索菲亞，我們把玩具收起來吧，地上還有玩具嗎？”
索菲亞：“有，球。”
你：“好，把球放進盒子裡面吧，還有嗎？”
索菲亞：“有，那是我的娃娃。”
你：“好，把娃娃也放進去吧，還有嗎？”
索菲亞：“有，有我的書。”
你：“好，把書也放進去，還有嗎？”
索菲亞：“沒有了。”
你：“好，我們收好啦。”

這正是你每天都要對 Java 集合做的事情。你外部迭代了一個集合，顯式地取出每個專案再加以處理，但是如果你只是跟索菲亞說：“把地上所有玩具都放進盒子裡”，那麼索菲亞就可以選擇一手拿娃娃一手拿球，或是選擇先拿離盒子最近的那個東西，再拿其他的東西。

採用內部迭代，專案可以透明地並行處理，或者用優化的順序進行處理，要是使用 Java 過去的外部迭代方法，這些優化都是很困難的。

這或許有點雞蛋裡挑骨頭，但這差不多就是 Java 8 引入流的原因了——Streams庫的內部迭代可以自動選擇一種是和你硬體的資料表示和並行實現。

特點二：只能遍歷一次

請注意，和迭代器一樣，流只能遍歷一次。當流遍歷完之後，我們就說這個流已經被消費掉了，你可以從原始資料那裡重新獲得一條新的流，但是卻不允許消費已消費掉的流。例如下面程式碼就會丟擲一個異常，說流已被消費掉了：

List<String> title = Arrays.asList("Wmyskxz", "Is", "Learning", "Java8", "In", "Action");
Stream<String> s = title.stream();
s.forEach(System.out::println);
s.forEach(System.out::println);
// 執行上面程式會報以下錯誤
/*
Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
    at java.util.stream.AbstractPipeline.sourceStageSpliterator(AbstractPipeline.java:279)
    at java.util.stream.ReferencePipeline$Head.forEach(ReferencePipeline.java:580)
    at Test1.main(Tester.java:17)
*/

特點三：方便的並行處理

Java 8 中不僅提供了方便的一些流操作（比如過濾、排序之類的），更重要的是對於並行處理有很好的支援，只需要加上.parallel()就行了！例如我們使用下面程式來說明一下多執行緒流操作的方便和快捷，並且與單執行緒做了一下對比：

COPYpublic class StreamParallelDemo {

    /** 總數 */
    private static int total = 100_000_000;

    public static void main(String[] args) {
        System.out.println(String.format("本計算機的核數：%d", Runtime.getRuntime().availableProcessors()));

        // 產生1000w個隨機數(1 ~ 100)，組成列表
        Random random = new Random();
        List<Integer> list = new ArrayList<>(total);

        for (int i = 0; i < total; i++) {
            list.add(random.nextInt(100));
        }

        long prevTime = getCurrentTime();
        list.stream().reduce((a, b) -> a + b).ifPresent(System.out::println);
        System.out.println(String.format("單執行緒計算耗時：%d", getCurrentTime() - prevTime));

        prevTime = getCurrentTime();
        // 只需要加上 .parallel() 就行了
        list.stream().parallel().reduce((a, b) -> a + b).ifPresent(System.out::println);
        System.out.println(String.format("多執行緒計算耗時：%d", getCurrentTime() - prevTime));

    }

    private static long getCurrentTime() {
        return System.currentTimeMillis();
    }
}

以上程式分別使用了單執行緒流和多執行緒流計算了一千萬個隨機數的和，輸出如下：

本計算機的核數：8
655028378
單執行緒計算耗時：4159
655028378
多執行緒計算耗時：540

並行流的內部使用了預設的 ForkJoinPool 分支/合併框架，它的預設執行緒數量就是你的處理器數量，這個值是由Runtime.getRuntime().availableProcessors()得到的（當然我們也可以全域性設定這個值）。我們也不再去過度的操心加鎖執行緒安全等一系列問題。

2 - 一些重要方法說明

stream: 返回資料流，集合作為其源
parallelStream: 返回並行資料流，集合作為其源
filter: 方法用於過濾出滿足條件的元素
map: 方法用於對映每個元素對應的結果
forEach: 方法遍歷該流中的每個元素
limit: 方法用於減少流的大小
sorted: 方法用來對流中的元素進行排序
anyMatch: 是否存在任意一個元素滿足條件（返回布林值）
allMatch: 是否所有元素都滿足條件（返回布林值）
noneMatch: 是否所有元素都不滿足條件（返回布林值）
collect: 方法是終端操作，這是通常出現在管道傳輸操作結束標記流的結束

3 - 一些使用示例

Filter 過濾

stringCollection
    .stream()
    .filter((s) -> s.startsWith("a"))
    .forEach(System.out::println);

Sort 排序

stringCollection
    .stream()
    .sorted()
    .filter((s) -> s.startsWith("a"))
    .forEach(System.out::println);

Map 對映

stringCollection
    .stream()
    .map(String::toUpperCase)
    .sorted((a, b) -> b.compareTo(a))
    .forEach(System.out::println);

Match 匹配

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 計數

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);

想了解更多請參考：https://www.wmyskxz.com/2019/08/03/java8-liu-cao-zuo-ji-ben-shi-yong-xing-neng-ce-shi/

六. Optional

到目前為止，臭名昭著的空指標異常是導致 Java 應用程式失敗的最常見原因。以前，為了解決空指標異常，Google公司著名的Guava專案引入了Optional類，Guava 通過使用檢查空值的方式來防止程式碼汙染，它鼓勵程式設計師寫更乾淨的程式碼。受到 Google Guava 的啟發，Optional類已經成為 Java 8 類庫的一部分。

Optional實際上是個容器：它可以儲存型別 T 的值，或者僅僅儲存 null。Optional提供很多有用的方法，這樣我們就不用顯式進行空值檢測。

我們下面用兩個小例子來演示如何使用 Optional 類：一個允許為空值，一個不允許為空值。

Optional<String> fullName = Optional.ofNullable(null);
System.out.println("Full Name is set? " + fullName.isPresent());
System.out.println("Full Name: " + fullName.orElseGet(() -> "[none]"));
System.out.println(fullName.map(s -> "Hey " + s + "!").orElse("Hey Stranger!"));

如果Optional類的例項為非空值的話，isPresent()返回true，否從返回false。為了防止 Optional 為空值，orElseGet()方法通過回撥函式來產生一個預設值。map()函式對當前Optional的值進行轉化，然後返回一個新的Optional例項。orElse()方法和orElseGet()方法類似，但是orElse接受一個預設值而不是一個回撥函式。下面是這個程式的輸出：

Full Name is set? false
Full Name: [none]
Hey Stranger!

讓我們來看看另一個例子：

Optional<String> firstName = Optional.of("Tom");
System.out.println("First Name is set? " + firstName.isPresent());
System.out.println("First Name: " + firstName.orElseGet(() -> "[none]"));
System.out.println(firstName.map(s -> "Hey " + s + "!").orElse("Hey Stranger!"));
System.out.println();

下面是程式的輸出：

First Name is set? true
First Name: Tom
Hey Tom!

Lambda 配合 Optinal 優雅解決 null

這裡假設我們有一個 person object，以及一個 person object 的 Optional wrapper：

Optional<T>如果不結合 Lambda 使用的話，並不能使原來繁瑣的 null check 變的簡單。

只有當Optional<T>結合 Lambda 一起使用的時候，才能發揮出其真正的威力！

我們現在就來對比一下下面四種常見的 null 處理中，Java 8 的 Lambda +Optional<T>和傳統 Java 兩者之間對於 null 的處理差異。

情況一：存在則繼續

情況二：存在則返回，無則返回不存在

情況三：存在則返回，無則由函式產生

情況四：奪命連環 null 檢查

由上述四種情況可以清楚地看到，Optional<T>+ Lambda 可以讓我們少寫很多ifElse塊。尤其是對於情況四那種奪命連環 null 檢查，傳統 Java 的寫法顯得冗長難懂，而新的Optional<T>+Lambda 則清新脫俗，清楚簡潔。

七. Data/Time API

Java 8 在包java.time下包含了一組全新的時間日期API。新的日期API和開源的Joda-Time庫差不多，但又不完全一樣，下面的例子展示了這組新API裡最重要的一些部分：

1 - Clock 時鐘

Clock類提供了訪問當前日期和時間的方法，Clock 是時區敏感的，可以用來取代System.currentTimeMillis()來獲取當前的微秒數。某一個特定的時間點也可以使用Instant類來表示，Instant類也可以用來建立老的java.util.Date物件。程式碼如下:

Clock clock = Clock.systemDefaultZone();
long millis = clock.millis();
Instant instant = clock.instant();
Date legacyDate = Date.from(instant);   // legacy java.util.Date

2 - Timezones 時區

在新 AP I中時區使用ZoneId來表示。時區可以很方便的使用靜態方法of來獲取到。時區定義了到 UTS 時間的時間差，在Instant時間點物件到本地日期物件之間轉換的時候是極其重要的。程式碼如下:

System.out.println(ZoneId.getAvailableZoneIds());
// prints all available timezone ids
ZoneId zone1 = ZoneId.of("Europe/Berlin");
ZoneId zone2 = ZoneId.of("Brazil/East");
System.out.println(zone1.getRules());
System.out.println(zone2.getRules());
// ZoneRules[currentStandardOffset=+01:00]
// ZoneRules[currentStandardOffset=-03:00]

3 - LocalTime 本地時間

LocalTime定義了一個沒有時區資訊的時間，例如晚上 10 點，或者 17:30:15。下面的例子使用前面程式碼建立的時區建立了兩個本地時間。之後比較時間並以小時和分鐘為單位計算兩個時間的時間差。程式碼如下:

LocalTime now1 = LocalTime.now(zone1);
LocalTime now2 = LocalTime.now(zone2);
System.out.println(now1.isBefore(now2));  // false
long hoursBetween = ChronoUnit.HOURS.between(now1, now2);
long minutesBetween = ChronoUnit.MINUTES.between(now1, now2);
System.out.println(hoursBetween);       // -3
System.out.println(minutesBetween);     // -239

LocalTime提供了多種工廠方法來簡化物件的建立，包括解析時間字串。程式碼如下:

LocalTime late = LocalTime.of(23, 59, 59);
System.out.println(late);       // 23:59:59
DateTimeFormatter germanFormatter = DateTimeFormatter
        .ofLocalizedTime(FormatStyle.SHORT)
        .withLocale(Locale.GERMAN);
LocalTime leetTime = LocalTime.parse("13:37", germanFormatter);
System.out.println(leetTime);   // 13:37

4 - LocalData 本地日期

LocalDate表示了一個確切的日期，比如2014-03-11。該物件值是不可變的，用起來和LocalTime基本一致。下面的例子展示瞭如何給Date物件加減天/月/年。另外要注意的是這些物件是不可變的，操作返回的總是一個新例項。程式碼如下:

LocalDate today = LocalDate.now();
LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS);
LocalDate yesterday = tomorrow.minusDays(2);
LocalDate independenceDay = LocalDate.of(2014, Month.JULY, 4);
DayOfWeek dayOfWeek = independenceDay.getDayOfWeek();

System.out.println(dayOfWeek);    // FRIDAY

從字串解析一個 LocalDate 型別和解析 LocalTime 一樣簡單。程式碼如下:

DateTimeFormatter germanFormatter = DateTimeFormatter
        .ofLocalizedDate(FormatStyle.MEDIUM)
        .withLocale(Locale.GERMAN);
LocalDate xmas = LocalDate.parse("24.12.2014", germanFormatter);
System.out.println(xmas);   // 2014-12-24

5 - LocalDateTime 本地日期時間

LocalDateTime同時表示了時間和日期，相當於前兩節內容合併到一個物件上了。LocalDateTime和LocalTime還有LocalDate一樣，都是不可變的。LocalDateTime提供了一些能訪問具體欄位的方法。程式碼如下:

LocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59);
DayOfWeek dayOfWeek = sylvester.getDayOfWeek();
System.out.println(dayOfWeek);      // WEDNESDAY
Month month = sylvester.getMonth();
System.out.println(month);          // DECEMBER
long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY);
System.out.println(minuteOfDay);    // 1439

只要附加上時區資訊，就可以將其轉換為一個時間點Instant物件，Instant時間點物件可以很容易的轉換為老式的java.util.Date。程式碼如下:

Instant instant = sylvester
        .atZone(ZoneId.systemDefault())
        .toInstant();
Date legacyDate = Date.from(instant);
System.out.println(legacyDate);     // Wed Dec 31 23:59:59 CET 2014

格式化LocalDateTime和格式化時間和日期一樣的，除了使用預定義好的格式外，我們也可以自己定義格式。程式碼如下:

DateTimeFormatter formatter =
    DateTimeFormatter
        .ofPattern("MMM dd, yyyy - HH:mm");
LocalDateTime parsed = LocalDateTime.parse("Nov 03, 2014 - 07:13", formatter);
String string = formatter.format(parsed);
System.out.println(string);     // Nov 03, 2014 - 07:13

和java.text.NumberFormat不一樣的是新版的DateTimeFormatter是不可變的，所以它是執行緒安全的。

八. 重複註解

自從 Java 5 引入了註解機制，這一特性就變得非常流行並且廣為使用。然而，使用註解的一個限制是相同的註解在同一位置只能宣告一次，不能宣告多次。Java 8 打破了這條規則，引入了重複註解機制，這樣相同的註解可以在同一地方宣告多次。

重複註解機制本身必須用@Repeatable註解。事實上，這並不是語言層面上的改變，更多的是編譯器的技巧，底層的原理保持不變。讓我們看一個快速入門的例子：

import java.lang.annotation.ElementType;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

public class RepeatingAnnotations {

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Filters {
        Filter[] value();
    }

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Repeatable(Filters.class)
    public @interface Filter {
        String value();
    };

    @Filter("filter1")
    @Filter("filter2")
    public interface Filterable {
    }

    public static void main(String[] args) {
        for(Filter filter: Filterable.class.getAnnotationsByType(Filter.class)) {
            System.out.println(filter.value());
        }
    }

}

正如我們看到的，這裡有個使用@Repeatable(Filters.class)註解的註解類Filter，Filters僅僅是Filter註解的陣列，但Java編譯器並不想讓程式設計師意識到Filters的存在。這樣，介面Filterable就擁有了兩次Filter（並沒有提到Filter）註解。

同時，反射相關的API提供了新的函式getAnnotationsByType()來返回重複註解的型別（請注意Filterable.class.getAnnotation(Filters.class)`經編譯器處理後將會返回Filters的例項）。

九. 擴充套件註解的支援

Java 8 擴充套件了註解的上下文。現在幾乎可以為任何東西添加註解：區域性變數、泛型類、父類與介面的實現，就連方法的異常也能添加註解。下面演示幾個例子：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.ArrayList;
import java.util.Collection;

public class Annotations {

    @Retention(RetentionPolicy.RUNTIME)
    @Target({ ElementType.TYPE_USE, ElementType.TYPE_PARAMETER })
    public @interface NonEmpty {
    }

    public static class Holder<@NonEmpty T> extends @NonEmpty Object {
        public void method() throws @NonEmpty Exception {
        }
    }

    @SuppressWarnings("unused")
    public static void main(String[] args) {
        final Holder<String> holder = new @NonEmpty Holder<String>();
        @NonEmpty Collection<@NonEmpty String> strings = new ArrayList<>();
    }

}

十. Base64

在 Java 8 中，Base64 編碼已經成為 Java 類庫的標準。它的使用十分簡單，下面讓我們看一個例子：

import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class Base64s {

    public static void main(String[] args) {
        final String text = "Base64 finally in Java 8!";

        final String encoded = Base64.getEncoder().encodeToString(text.getBytes(StandardCharsets.UTF_8));
        System.out.println(encoded);

        final String decoded = new String(Base64.getDecoder().decode(encoded), StandardCharsets.UTF_8);
        System.out.println(decoded);
    }

}

程式在控制檯上輸出了編碼後的字元與解碼後的字元：

QmFzZTY0IGZpbmFsbHkgaW4gSmF2YSA4IQ==
Base64 finally in Java 8!

Base64 類同時還提供了對 URL、MIME 友好的編碼器與解碼器（Base64.getUrlEncoder() / Base64.getUrlDecoder(),Base64.getMimeEncoder() / Base64.getMimeDecoder()）。

十一. JavaFX

JavaFX是一個強大的圖形和多媒體處理工具包集合，它允許開發者來設計、建立、測試、除錯和部署富客戶端程式，並且和Java一樣跨平臺。從Java8開始，JavaFx已經內建到了JDK中。關於JavaFx更詳細的文件可參考JavaFX中文文件。

十二. 其它

1. JDBC4.2規範

JDBC4.2主要有以下幾點改動：

增加了對REF Cursor的支援
修改返回值大小範圍（update count）
增加了java.sql.DriverAction介面
增加了java.sql.SQLType介面
增加了java.sql.JDBCtype列舉
對java.time包時間型別的支援

2. 更好的型別推測機制

Java 8 在型別推測方面有了很大的提高。在很多情況下，編譯器可以推測出確定的引數型別，這樣就能使程式碼更整潔。讓我們看一個例子：

public class Value<T> {

    public static<T> T defaultValue() {
        return null;
    }

    public T getOrDefault(T value, T defaultValue) {
        return (value != null) ? value : defaultValue;
    }

}

這裡是Value<String>型別的用法。

public class TypeInference {

    public static void main(String[] args) {
        final Value<String> value = new Value<>();
        value.getOrDefault("22", Value.defaultValue());
    }

}

Value.defaultValue()的引數型別可以被推測出，所以就不必明確給出。在Java 7中，相同的例子將不會通過編譯，正確的書寫方式是Value.<String>defaultValue()。

3. HashMap效能提升

Java 8 中，HashMap 內部實現又引入了紅黑樹，使得 HashMap 的總體效能相較於 Java 7 有比較明顯的提升。以下是對 Hash 均勻和不均勻的情況下的效能對比

Hash較均勻的情況

Hash極不均勻的情況

想要了解更多 HashMap 的童鞋戳這裡吧：傳送門

4. IO/NIO 的改進

Java 8 對IO/NIO也做了一些改進。主要包括：改進了java.nio.charset.Charset的實現，使編碼和解碼的效率得以提升，也精簡了jre/lib/charsets.jar包；優化了String(byte[], *)構造方法和String.getBytes()方法的效能；還增加了一些新的IO/NIO方法，使用這些方法可以從檔案或者輸入流中獲取流（java.util.stream.Stream），通過對流的操作，可以簡化文字行處理、目錄遍歷和檔案查詢。

新增的 API 如下：

BufferedReader.line(): 返回文字行的流Stream<String>
File.lines(Path, Charset): 返回文字行的流Stream<String>
File.list(Path): 遍歷當前目錄下的檔案和目錄
File.walk(Path, int, FileVisitOption): 遍歷某一個目錄下的所有檔案和指定深度的子目錄
File.find(Path, int, BiPredicate, FileVisitOption...): 查詢相應的檔案

下面就是用流式操作列出當前目錄下的所有檔案和目錄：

Files.list(new File(".").toPath()).forEach(System.out::println);

5. JavaScript 引擎 Nashorn

Java 8 提供了一個新的Nashorn javascript引擎，它允許我們在 JVM 上執行特定的 javascript 應用。Nashorn javascript 引擎只是javax.script.ScriptEngine另一個實現，而且規則也一樣，允許Java和JavaScript互相操作。這裡有個小例子：

ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");

System.out.println(engine.getClass().getName());
System.out.println("Result:" + engine.eval("function f(){return 1;}; f() + 1;"));

輸出如下：

jdk.nashorn.api.scripting.NashornScriptEngine
Result: 2

6. 併發（Concurrency）

在新增Stream機制與Lambda的基礎之上，在java.util.concurrent.ConcurrentHashMap中加入了一些新方法來支援聚集操作。同時也在java.util.concurrent.ForkJoinPool類中加入了一些新方法來支援共有資源池（common pool）（請檢視我們關於Java 併發的免費課程）。

新增的java.util.concurrent.locks.StampedLock類提供一直基於容量的鎖，這種鎖有三個模型來控制讀寫操作（它被認為是不太有名的java.util.concurrent.locks.ReadWriteLock類的替代者）。

在java.util.concurrent.atomic包中還增加了下面這些類：

DoubleAccumulator
DoubleAdder
LongAccumulator
LongAdder

7. 類依賴分析器jdeps

Jdeps是一個功能強大的命令列工具，它可以幫我們顯示出包層級或者類層級java類檔案的依賴關係。它接受class檔案、目錄、jar檔案作為輸入，預設情況下，jdeps會輸出到控制檯。

作為例子，讓我們看看現在很流行的 Spring 框架的庫的依賴關係報告。為了讓報告短一些，我們只分析一個 jar:org.springframework.core-3.0.5.RELEASE.jar.

jdeps org.springframework.core-3.0.5.RELEASE.jar這個命令輸出內容很多，我們只看其中的一部分，這些依賴關係根絕包來分組，如果依賴關係在classpath裡找不到，就會顯示 not found。

C:\Program Files\Java\jdk1.8.0\jre\lib\rt.jar
   org.springframework.core (org.springframework.core-3.0.5.RELEASE.jar)
      -> java.io
      -> java.lang
      -> java.lang.annotation
      -> java.lang.ref
      -> java.lang.reflect
      -> java.util
      -> java.util.concurrent
      -> org.apache.commons.logging                         not found
      -> org.springframework.asm                            not found
      -> org.springframework.asm.commons                    not found
   org.springframework.core.annotation (org.springframework.core-3.0.5.RELEASE.jar)
      -> java.lang
      -> java.lang.annotation
      -> java.lang.reflect
      -> java.util

8. JVM 的 PermGen 空間被移除

PermGen空間被移除了，取而代之的是Metaspace（JEP 122）。JVM 選項-XX:PermSize與-XX:MaxPermSize分別被-XX:MetaSpaceSize與-XX:MaxMetaspaceSize所代替。

區別：

元空間並不在虛擬機器中，而是使用本地記憶體
預設情況下，元空間的大小僅受本地記憶體限制
也可以通過-XX：MetaspaceSize指定元空間大小

參考資料

「MoreThanJava」Day 7：介面詳解 - https://www.wmyskxz.com/2020/08/13/morethanjava-day-7-jie-kou-xiang-jie/
【知乎問題】Lambda 表示式有何用處？如何使用？ | @Mingqi - https://www.zhihu.com/question/20125256
Java8新特性及使用(一) | 閃爍之狐 - http://blinkfox.com/2018/11/13/hou-duan/java/java8-xin-te-xing-ji-shi-yong-yi/#toc-heading-21
Java8新特性及使用(二) | 閃爍之狐 - http://blinkfox.com/2018/11/14/hou-duan/java/java8-xin-te-xing-ji-shi-yong-er/

增Stream機制與Lambda中加入了一些新方法來支援聚集操作

更多Supplier介面