乾貨 | Java8 新特性指導手冊

本教程翻譯整理自 github.com/winterbe/ja…

你還可以去我的網站去檢視此手冊哦：Java8 新特性指導手冊

介面內允許新增預設實現的方法

Java 8 允許我們通過 default 關鍵字對介面中定義的抽象方法提供一個預設的實現。

請看下面示例程式碼：

// 定義一個公式介面
interface Formula {
    // 計算
    double calculate(int a);

    // 求平方根
    default double sqrt(int a) {
        return Math.sqrt(a);
    }
}
複製程式碼

在上面這個介面中，我們除了定義了一個抽象方法 calculate，還定義了一個帶有預設實現的方法 sqrt。我們在實現這個介面時，可以只需要實現 calculate 方法，預設方法 sqrt 可以直接呼叫即可，也就是說我們可以不必強制實現 sqrt 方法。

補充：通過 default 關鍵字這個新特性，可以非常方便地對之前的介面做擴充，而此介面的實現類不必做任何改動。

Formula formula = new Formula() {
    @Override
    public double calculate(int a) {
        return sqrt(a * 100);
    }
};

formula.calculate(100);     // 100.0
formula.sqrt(16);           // 4.0
複製程式碼

上面通過匿名物件實現了 Formula 介面。但是即使是這樣，我們為了完成一個 sqrt(a * 100) 簡單計算，就寫了 6 行程式碼，很是冗餘。

Lambda 表示式

在學習 Lambda 表示式之前，我們先來看一段老版本的示例程式碼，其對一個含有字串的集合進行排序：

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 方法，入參是一個 List 集合，和一個 Comparator 比較器，以便對給定的 List 集合進行排序。上面的示例程式碼建立了一個匿名內部類作為入參，這種類似的操作在我們日常的工作中隨處可見。

Java 8 中不再推薦這種寫法，而是推薦使用 Lambda 表達：

Collections.sort(names, (String a, String b) -> {
    return b.compareTo(a);
});
複製程式碼

正如你看到的，上面這段程式碼變得簡短很多而且易於閱讀。但是我們還可以再精煉一點：

Collections.sort(names, (String a, String b) -> b.compareTo(a));
複製程式碼

對於只包含一行方法的程式碼塊，我們可以省略大括號，直接 return 關鍵程式碼即可。追求極致，我們還可以讓它再短點：

names.sort((a, b) -> b.compareTo(a));
複製程式碼

List 集合現在已經新增了 sort 方法。而且 Java 編譯器能夠根據型別推斷機制判斷出引數型別，這樣，你連入參的型別都可以省略啦，怎麼樣，是不是感覺很強大呢！

函式式介面 Functional Interface

丟擲一個疑問：在我們書寫一段 Lambda 表示式後（比如上一章節中匿名內部類的 Lambda 表示式縮寫形式），Java 編譯器是如何進行型別推斷的，它又是怎麼知道重寫的哪個方法的？

需要說明的是，不是每個介面都可以縮寫成 Lambda 表示式。只有那些函式式介面（Functional Interface）才能縮寫成 Lambda 表示式。

那麼什麼是函式式介面（Functional Interface）呢？

所謂函式式介面（Functional Interface）就是隻包含一個抽象方法的宣告。針對該介面型別的所有 Lambda 表示式都會與這個抽象方法匹配。

注意：你可能會有疑問，Java 8 中不是允許通過 defualt 關鍵字來為介面新增預設方法嗎？那它算不算抽象方法呢？答案是：不算。因此，你可以毫無顧忌的新增預設方法，它並不違反函式式介面（Functional Interface）的定義。

總結一下：只要介面中僅僅包含一個抽象方法，我們就可以將其改寫為 Lambda 表示式。為了保證一個介面明確的被定義為一個函式式介面（Functional Interface），我們需要為該介面新增註解：@FunctionalInterface。這樣，一旦你新增了第二個抽象方法，編譯器會立刻丟擲錯誤提示。

示例程式碼：

@FunctionalInterface
interface Converter<F, T> {
    T convert(F from);
}
複製程式碼

示例程式碼2：

Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123");
System.out.println(converted);    // 123
複製程式碼

注意：上面的示例程式碼，即使去掉 @FunctionalInterface 也是好使的，它僅僅是一種約束而已。

便捷的引用類的構造器及方法

小夥伴們，還記得上一個章節這段示例程式碼麼：

@FunctionalInterface
interface Converter<F, T> {
    T convert(F from);
}
複製程式碼

Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123");
System.out.println(converted);    // 123
複製程式碼

上面這段程式碼，通過 Java 8 的新特性，進一步簡化上面的程式碼：

Converter<String, Integer> converter = Integer::valueOf;
Integer converted = converter.convert("123");
System.out.println(converted);   // 123
複製程式碼

Java 8 中允許你通過 :: 關鍵字來引用類的方法或構造器。上面的程式碼簡單的示例瞭如何引用靜態方法，當然，除了靜態方法，我們還可以引用普通方法：

class Something {
    String startsWith(String s) {
        return String.valueOf(s.charAt(0));
    }
}
複製程式碼

Something something = new Something();
Converter<String, String> converter = something::startsWith;
String converted = converter.convert("Java");
System.out.println(converted);    // "J"
複製程式碼

接下來，我們再來看看如何通過 :: 關鍵字來引用類的構造器。首先，我們先來定義一個示例類，在類中宣告兩個構造器：

class Person {
    String firstName;
    String lastName;

    Person() {}

    Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}
複製程式碼

然後，我們再定義一個工廠介面，用來生成 Person 類：

// Person 工廠
interface PersonFactory<P extends Person> {
    P create(String firstName, String lastName);
}
複製程式碼

我們可以通過 :: 關鍵字來引用 Person 類的構造器，來代替手動去實現這個工廠介面：

// 直接引用 Person 構造器
PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");
複製程式碼

Person::new 這段程式碼，能夠直接引用 Person 類的構造器。然後 Java 編譯器能夠根據上下文選中正確的構造器去實現 PersonFactory.create 方法。

Lambda 訪問外部變數及介面預設方法

在本章節中，我們將會討論如何在 lambda 表示式中訪問外部變數（包括：區域性變數，成員變數，靜態變數，介面的預設方法.），它與匿名內部類訪問外部變數很相似。

訪問區域性變數

在 Lambda 表示式中，我們可以訪問外部的 final 型別變數，如下面的示例程式碼：

// 轉換器
@FunctionalInterface
interface Converter<F, T> {
    T convert(F from);
}
複製程式碼

final int num = 1;
Converter<Integer, String> stringConverter =
        (from) -> String.valueOf(from + num);

stringConverter.convert(2);     // 3
複製程式碼

與匿名內部類不同的是，我們不必顯式宣告 num 變數為 final 型別，下面這段程式碼同樣有效：

int num = 1;
Converter<Integer, String> stringConverter =
        (from) -> String.valueOf(from + num);

stringConverter.convert(2);     // 3
複製程式碼

但是 num 變數必須為隱式的 final 型別，何為隱式的 final 呢？就是說到編譯期為止，num 物件是不能被改變的，如下面這段程式碼，就不能被編譯通過：

int num = 1;
Converter<Integer, String> stringConverter =
        (from) -> String.valueOf(from + num);
num = 3;
複製程式碼

在 lambda 表示式內部改變 num 值同樣編譯不通過，需要注意, 比如下面的示例程式碼：

int num = 1;
Converter<Integer, String> converter = (from) -> {
	String value = String.valueOf(from + num);
	num = 3;
	return value;
};
複製程式碼

訪問成員變數和靜態變數

上一章節中，瞭解瞭如何在 Lambda 表示式中訪問區域性變數。與區域性變數相比，在 Lambda 表示式中對成員變數和靜態變數擁有讀寫許可權：

    @FunctionalInterface
    interface Converter<F, T> {
        T convert(F from);
    }
複製程式碼

class Lambda4 {
        // 靜態變數
        static int outerStaticNum;
        // 成員變數
        int outerNum;

        void testScopes() {
            Converter<Integer, String> stringConverter1 = (from) -> {
                // 對成員變數賦值
                outerNum = 23;
                return String.valueOf(from);
            };

            Converter<Integer, String> stringConverter2 = (from) -> {
                // 對靜態變數賦值
                outerStaticNum = 72;
                return String.valueOf(from);
            };
        }
    }
複製程式碼

訪問介面的預設方法

還記得第一章節中定義的那個 Formula (公式) 介面嗎？

@FunctionalInterface
interface Formula {
	// 計算
	double calculate(int a);

	// 求平方根
	default double sqrt(int a) {
		return Math.sqrt(a);
	}
}
複製程式碼

當時，我們在介面中定義了一個帶有預設實現的 sqrt 求平方根方法，在匿名內部類中我們可以很方便的訪問此方法：

Formula formula = new Formula() {
	@Override
	public double calculate(int a) {
		return sqrt(a * 100);
	}
};
複製程式碼

但是在 lambda 表示式中可不行：

Formula formula = (a) -> sqrt(a * 100);
複製程式碼

帶有預設實現的介面方法，是不能在 lambda 表示式中訪問的，上面這段程式碼將無法被編譯通過。

內建的函式式介面

JDK 1.8 API 包含了很多內建的函式式介面。其中就包括我們在老版本中經常見到的 Comparator 和 Runnable，Java 8 為他們都新增了 @FunctionalInterface 註解，以用來支援 Lambda 表示式。

值得一提的是，除了 Comparator 和 Runnable 外，還有一些新的函式式介面，它們很多都借鑑於知名的 Google Guava 庫。

對於它們，即使你已經非常熟悉了，還是最好了解一下的：

Predicate 斷言

Predicate 是一個可以指定入參型別，並返回 boolean 值的函式式介面。它內部提供了一些帶有預設實現的方法，可以被用來組合一個複雜的邏輯判斷（and, or, negate）：

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 不同，它不接受入參，直接為我們生產一個指定的結果，有點像生產者模式：

class Person {
    String firstName;
    String lastName;

    Person() {}

    Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}
複製程式碼

Supplier<Person> personSupplier = Person::new;
personSupplier.get();   // new Person
複製程式碼

Consumer 消費者

對於 Consumer，我們需要提供入參，用來被消費，如下面這段示例程式碼：

class Person {
    String firstName;
    String lastName;

    Person() {}

    Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}
複製程式碼

Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
greeter.accept(new Person("Luke", "Skywalker"));
複製程式碼

Comparator

Comparator 在 Java 8 之前是使用比較普遍的。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），要知道在 Java 程式設計中，空指標異常可是臭名昭著的。

讓我們來快速瞭解一下 Optional 要如何使用！你可以將 Optional 看做是包裝物件（可能是 null, 也有可能非 null）的容器。當你定義了一個方法，這個方法返回的物件可能是空，也有可能非空的時候，你就可以考慮用 Optional 來包裝它，這也是在 Java 8 被推薦使用的做法。

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 流

這一章節，我們開始步入學習 Stream 流。

什麼是 Stream 流？

簡單來說，我們可以使用 java.util.Stream 對一個包含一個或多個元素的集合做各種操作。這些操作可能是 中間操作 亦或是 終端操作。終端操作會返回一個結果，而中間操作會返回一個 Stream 流。

需要注意的是，你只能對實現了 java.util.Collection 介面的類做流的操作。

Map 不支援 Stream 流。

Stream 流支援同步執行，也支援併發執行。

讓我們開始步入學習的旅程吧！Go !

Filter 過濾

首先，我們建立一個 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");
複製程式碼

Filter 的入參是一個 Predicate, 上面已經說到，Predicate 是一個斷言的中間操作，它能夠幫我們篩選出我們需要的集合元素。它的返參同樣是一個 Stream 流，我們可以通過 foreach 終端操作，來列印被篩選的元素：

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

// "aaa2", "aaa1"
複製程式碼

注意：foreach 是一個終端操作，它的返參是 void, 我們無法對其再次進行流操作。

Sorted 排序

Sorted 同樣是一箇中間操作，它的返參是一個 Stream 流。另外，我們可以傳入一個 Comparator 用來自定義排序，如果不傳，則使用預設的排序規則。

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

// "aaa1", "aaa2"
複製程式碼

需要注意，sorted 不會對 stringCollection 做出任何改變，stringCollection 還是原有的那些個元素，且順序不變：

System.out.println(stringCollection);
// ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1
複製程式碼

Map 轉換

中間操作 Map 能夠幫助我們將 List 中的每一個元素做功能處理。例如下面的示例，通過 map 我們將每一個 string 轉成大寫：

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

// "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1"
複製程式碼

另外，我們還可以做物件之間的轉換，業務中比較常用的是將 DO（資料庫物件）轉換成 BO（業務物件）。

Match 匹配

顧名思義，match 用來做匹配操作，它的返回值是一個 boolean 型別。通過 match, 我們可以方便的驗證一個 list 中是否存在某個型別的元素。

// 驗證 list 中 string 是否有以 a 開頭的, 匹配到第一個，即返回 true
boolean anyStartsWithA =
    stringCollection
        .stream()
        .anyMatch((s) -> s.startsWith("a"));

System.out.println(anyStartsWithA);      // true

// 驗證 list 中 string 是否都是以 a 開頭的
boolean allStartsWithA =
    stringCollection
        .stream()
        .allMatch((s) -> s.startsWith("a"));

System.out.println(allStartsWithA);      // false

// 驗證 list 中 string 是否都不是以 z 開頭的,
boolean noneStartsWithZ =
    stringCollection
        .stream()
        .noneMatch((s) -> s.startsWith("z"));

System.out.println(noneStartsWithZ);      // true
複製程式碼

Count 計數

count 是一個終端操作，它能夠統計 stream 流中的元素總數，返回值是 long 型別。

// 先對 list 中字串開頭為 b 進行過濾，讓後統計數量
long startsWithB =
    stringCollection
        .stream()
        .filter((s) -> s.startsWith("b"))
        .count();

System.out.println(startsWithB);    // 3
複製程式碼

Reduce

Reduce 中文翻譯為：減少、縮小。通過入參的 Function，我們能夠將 list 歸約成一個值。它的返回型別是 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"
複製程式碼

Parallel-Streams 並行流

前面章節我們說過，stream 流是支援順序和並行的。順序流操作是單執行緒操作，而並行流是通過多執行緒來處理的，能夠充分利用物理機多核 CPU 的優勢，同時處理速度更快。

首先，我們建立一個包含 1000000 UUID list 集合。

int max = 1000000;
List<String> values = new ArrayList<>(max);
for (int i = 0; i < max; i++) {
    UUID uuid = UUID.randomUUID();
    values.add(uuid.toString());
}
複製程式碼

分別通過順序流和並行流，對這個 list 進行排序，測算耗時:

順序流排序

// 納秒
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("順序流排序耗時: %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("並行流排序耗時: %d ms", millis));

// 並行流排序耗時: 472 ms
複製程式碼

正如你所見，同樣的邏輯處理，通過並行流，我們的效能提升了近 50%。完成這一切，我們需要做的僅僅是將 stream 改成了 parallelStream。

Map 集合

前面已經提到過 Map 是不支援 Stream 流的，因為 Map 介面並沒有像 Collection 介面那樣，定義了 stream() 方法。但是，我們可以對其 key, values, entry 使用流操作，如 map.keySet().stream(), map.values().stream() 和 map.entrySet().stream().

另外, JDK 8 中對 map 提供了一些其他新特性:

Map<Integer, String> map = new HashMap<>();

for (int i = 0; i < 10; i++) {
    // 與老版不同的是，putIfAbent() 方法在 put 之前，
    // 會判斷 key 是否已經存在，存在則直接返回 value, 否則 put, 再返回 value
    map.putIfAbsent(i, "val" + i);
}

// forEach 可以很方便地對 map 進行遍歷操作
map.forEach((key, value) -> System.out.println(value));
複製程式碼

除了上面的 putIfAbsent() 和 forEach() 外，我們還可以很方便地對某個 key 的值做相關操作：

// computeIfPresent(), 當 key 存在時，才會做相關處理
// 如下：對 key 為 3 的值，內部會先判斷值是否存在，存在，則做 value + key 的拼接操作
map.computeIfPresent(3, (num, val) -> val + num);
map.get(3);             // val33

// 先判斷 key 為 9 的元素是否存在，存在，則做刪除操作
map.computeIfPresent(9, (num, val) -> null);
map.containsKey(9);     // false

// computeIfAbsent(), 當 key 不存在時，才會做相關處理
// 如下：先判斷 key 為 23 的元素是否存在，不存在，則新增
map.computeIfAbsent(23, num -> "val" + num);
map.containsKey(23);    // true

// 先判斷 key 為 3 的元素是否存在，存在，則不做任何處理
map.computeIfAbsent(3, num -> "bam");
map.get(3);             // val33
複製程式碼

關於刪除操作，JDK 8 中提供了能夠新的 remove() API:

map.remove(3, "val3");
map.get(3);             // val33

map.remove(3, "val33");
map.get(3);             // null
複製程式碼

如上程式碼，只有當給定的 key 和 value 完全匹配時，才會執行刪除操作。

關於新增方法，JDK 8 中提供了帶有預設值的 getOrDefault() 方法：

// 若 key 42 不存在，則返回 not found
map.getOrDefault(42, "not found");  // not found
複製程式碼

對於 value 的合併操作也變得更加簡單：

// merge 方法，會先判斷進行合併的 key 是否存在，不存在，則會新增元素
map.merge(9, "val9", (value, newValue) -> value.concat(newValue));
map.get(9);             // val9

// 若 key 的元素存在，則對 value 執行拼接操作
map.merge(9, "concat", (value, newValue) -> value.concat(newValue));
map.get(9);             // val9concat
複製程式碼

新的日期 API

Java 8 中在包 java.time 下新增了新的日期 API. 它和 Joda-Time 庫相似，但又不完全相同。接下來，我會通過一些示例程式碼介紹一下新 API 中最關鍵的特性：

Clock

Clock 提供對當前日期和時間的訪問。我們可以利用它來替代 System.currentTimeMillis() 方法。另外，通過 clock.instant() 能夠獲取一個 instant 例項，此例項能夠方便地轉換成老版本中的 java.util.Date 物件。

Clock clock = Clock.systemDefaultZone();
long millis = clock.millis();

Instant instant = clock.instant();
Date legacyDate = Date.from(instant);   // 老版本 java.util.Date
複製程式碼

Timezones 時區

ZoneId 代表時區類。通過靜態工廠方法方便地獲取它，入參我們可以傳入某個時區編碼。另外，時區類還定義了一個偏移量，用來在當前時刻或某時間與目標時區時間之間進行轉換。

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]
複製程式碼

LocalTime

LocalTime 表示一個沒有指定時區的時間類，例如，10 p.m.或者 17：30:15，下面示例程式碼中，將會使用上面建立的時區物件建立兩個 LocalTime。然後我們會比較兩個時間，並計算它們之間的小時和分鐘的不同。

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
複製程式碼

LocalDate

LocalDate 是一個日期物件，例如：2014-03-11。它和 LocalTime 一樣是個 final 型別物件。下面的例子演示瞭如何通過加減日，月，年等來計算一個新的日期。

LocalDate, LocalTime, 因為是 final 型別的物件，每一次操作都會返回一個新的時間物件。

LocalDate today = LocalDate.now();
// 今天加一天
LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS);
// 明天減兩天
LocalDate yesterday = tomorrow.minusDays(2);

// 2014 年七月的第四天
LocalDate independenceDay = LocalDate.of(2014, Month.JULY, 4);
DayOfWeek dayOfWeek = independenceDay.getDayOfWeek();
System.out.println(dayOfWeek);    // 星期五
複製程式碼

也可以直接解析日期字串，生成 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

複製程式碼

LocalDateTime

LocalDateTime 是一個日期-時間物件。你也可以將其看成是 LocalDate 和 LocalTime 的結合體。操作上，也大致相同。

LocalDateTime 同樣是一個 final 型別物件。

LocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59);

DayOfWeek dayOfWeek = sylvester.getDayOfWeek();
System.out.println(dayOfWeek);      // 星期三

Month month = sylvester.getMonth();
System.out.println(month);          // 十二月

// 獲取改時間是該天中的第幾分鐘
long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY);
System.out.println(minuteOfDay);    // 1439
複製程式碼

如果再加上的時區資訊，LocalDateTime 還能夠被轉換成 Instance 例項。Instance 能夠被轉換成老版本中 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 物件就和格式化 LocalDate 或者 LocalTime 一樣。除了使用預定義的格式以外，也可以自定義格式化輸出。

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 類是 final 型別的，同時也是執行緒安全的。更多細節請檢視這裡

Annotations 註解

在 Java 8 中，註解是可以重複的。讓我通過下面的示例程式碼，來看看到底是咋回事。

首先，我們定義一個包裝註解，裡面包含了一個有著實際註解的陣列：

@interface Hints {
    Hint[] value();
}

@Repeatable(Hints.class)
@interface Hint {
    String value();
}
複製程式碼

Java 8 中，通過 @Repeatable，允許我們對同一個類使用多重註解：

第一種形態：使用註解容器（老方法）

@Hints({@Hint("hint1"), @Hint("hint2")})
class Person {}
複製程式碼

第二種形態：使用可重複註解（新方法）

@Hint("hint1")
@Hint("hint2")
class Person {}
複製程式碼

使用第二種形態，Java 編譯器能夠在內部自動對 @Hint 進行設定。這對於需要通過反射來讀取註解資訊時，是非常重要的。

Hint hint = Person.class.getAnnotation(Hint.class);
System.out.println(hint);                   // null

Hints hints1 = Person.class.getAnnotation(Hints.class);
System.out.println(hints1.value().length);  // 2

Hint[] hints2 = Person.class.getAnnotationsByType(Hint.class);
System.out.println(hints2.length);          // 2
複製程式碼

儘管我們絕對不會在 Person 類上宣告 @Hints 註解，但是它的資訊仍然是可以通過 getAnnotation(Hints.class) 來讀取的。並且，getAnnotationsByType 方法會更方便，因為它賦予了所有 @Hints 註解標註的方法直接的訪問許可權。

@Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
@interface MyAnnotation {}
複製程式碼

結語

Java 8 新特性的程式設計指南到此就告一段落了。當然，還有很多內容需要進一步研究和說明。這就需要靠讀者您來對 JDK 8 進一步探究了，例如：Arrays.parallelSort, StampedLock 和 CompletableFuture 等等，我這裡也僅是起到拋磚引玉的作用而已。

最後，我希望這個教程能夠對您有所幫助，也希望您閱讀愉快。