乾貨 | Java8 新特性教程

時間 2019-11-06

標籤乾貨 java8 java 特性教程欄目 Java 简体版

原文原文鏈接

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

更多幹貨文章，請關注筆者公衆號: 小哈學Java (ID: xiaoha_java), 專一於分享Java領域乾貨文章, 不限於 BAT 面試題，算法，數據庫，Spring Boot, Spring Cloud & SOA, 高併發，JVM 調優, 數據庫，Docker 容器， ELK, DevOps 等相關知識，另外，關注回覆「資源」，便可獲取全文最熱的 Java 面試&架構學習資源喲~java

你還能夠去個人網站去查看此教程哦：Java8 新特性教程git

接口內容許添加默認實現的方法

Java 8 容許咱們經過 default 關鍵字對接口中定義的抽象方法提供一個默認的實現。算法

請看下面示例代碼：數據庫

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

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

在上面這個接口中，咱們除了定義了一個抽象方法 calculate，還定義了一個帶有默認實現的方法 sqrt。咱們在實現這個接口時，能夠只須要實現 calculate 方法，默認方法 sqrt 能夠直接調用便可，也就是說咱們能夠沒必要強制實現 sqrt 方法。編程

補充：經過 default 關鍵字這個新特性，能夠很是方便地對以前的接口作拓展，而此接口的實現類沒必要作任何改動。c#

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 行代碼，非常冗餘。api

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 等等，我這裏也僅是起到拋磚引玉的做用而已。

最後，我但願這個教程可以對您有所幫助，也但願您閱讀愉快。