JDK8 指南（譯）

阿新 • • 發佈：2017-11-14

-c 作用表現字母 lba param nonnull pri 消費者

翻譯自 java8-tutorial

新特性

Default Methods for Interfaces(接口的默認方法)

Java 8 使我們能夠通過使用 default 關鍵字將非抽象方法實現添加到接口。這個功能也被稱為虛擬擴展方法。

這是我們的第一個例子：

interface Formula {
    double calculate(int a);

    default double sqrt(int a) {
        return Math.sqrt(a);
    }
}

除了抽象方法 calculate ，接口 Formula 還定義了默認方法 sqrt。具體類只需要執行抽象方法計算。默認的方法 sqrt

可以用於開箱即用。

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 行代碼。正如我們將在下一節中看到的，在 Java 8 中實現單個方法對象有更好的方法。

Lambda expressions(Lambda 表達式)

讓我們從一個簡單的例子來說明如何在以前版本的 Java 中對字符串列表進行排序：

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 為了對指定的列表進行排序，接受一個列表和一個比較器。您會發現自己經常需要創建匿名比較器並將其傳遞給排序方法。

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

列表現在有一個 sort 方法。此外，java 編譯器知道參數類型，所以你可以不指定入參的數據類型。讓我們深入探討如何使用 lambda 表達式。

Functional Interfaces(函數接口)

lambda 表達式如何適應 Java 的類型系統？每個 lambda 對應一個由接口指定的類型。一個所謂的函數接口必須包含一個抽象方法聲明。該類型的每個 lambda 表達式都將與此抽象方法匹配。由於默認方法不是抽象的，所以你可以自由地添加默認方法到你的函數接口。

只要保證接口僅包含一個抽象方法，就可以使用任意的接口作為lambda表達式。為確保您的接口符合要求，您應該添加 @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

請記住，如果 @FunctionalInterface 註解被省略，代碼也是有效的。

Method and Constructor References(方法和構造器引用)

上面的示例代碼可以通過使用靜態方法引用進一步簡化：

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 對象的 PersonFactory 接口。

interface PersonFactory<P extends Person> {
    P create(String firstName, String lastName);
}

我們不是手動實現工廠，而是通過構造引用將所有東西粘合在一起：

PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");

我們通過 Person::new 來創建一個 Person 構造器的引用。Java 編譯器會根據PersonFactory.create 的簽名自動匹配正確的構造器。

Lambda Scopes(Lambda 作用域)

從 lambda 表達式訪問外部作用域變量與匿名對象非常相似。您可以訪問本地外部作用域的常量以及實例的成員變量和靜態變量。

Accessing local variables(訪問本地變量)

我們可以訪問 lambda 表達式作用域外部的常量：

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 必須是隱式常量的。下面的代碼不能編譯通過：

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

此外，在 lambda 表達式中對 num 做寫操作也是被禁止的。

Accessing fields and static variables(訪問成員變量和靜態變量)

與局部變量相比，我們既可以在 lambda 表達式中讀寫實例的成員變量，也可以讀寫實例的靜態變量。這種行為在匿名對象中是眾所周知的。

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

Accessing Default Interface Methods（訪問默認的接口方法）

還記得第一節的 formula 例子嗎？ Formula 接口定義了一個默認方法 sqrt，它可以被每個 formula 實例（包括匿名對象）訪問。這個特性不適用於 lambda 表達式。

默認方法不能被 lambda 表達式訪問。下面的代碼不能編譯通過：

Formula formula = (a) -> sqrt(a * 100);

Built-in Functional Interfaces(內置函數接口)

JDK 1.8 API 包含許多內置的功能接口。它們中的一些在較早的Java版本（比如 Comparator 或 Runnable）中是眾所周知的。這些現有的接口通過 @FunctionalInterfaceannotation 註解被擴展為支持 Lambda。

但是，Java 8 API 也提供了不少新的函數接口。其中一些新接口在 Google Guava 庫中是眾所周知的。即使您熟悉這個庫，也應該密切關註如何通過一些有用的方法擴展來擴展這些接口。

Predicates

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

Functions

Function 接受一個參數並產生一個結果。可以使用默認方法將多個函數鏈接在一起（compose、andThen）。

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

backToString.apply("123");     // "123"

Suppliers

Supplier 產生一個泛型結果。與 Function 不同，Supplier 不接受參數。

Supplier<Person> personSupplier = Person::new;
personSupplier.get();   // new Person

Consumers

Consumer 表示要在一個輸入參數上執行的操作。

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

Comparators

比較器在老版本的 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

Optionals

Optional 不是功能性接口，而是防止 NullPointerException 的好工具。這是下一節的一個重要概念，所以讓我們快速看看 Optional 是如何工作的。

可選是一個簡單的容器，其值可以是 null 或非 null。想想一個可能返回一個非空結果的方法，但有時候什麽都不返回。不是返回null，而是返回 Java 8 中的 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"

Streams

java.util.Stream 表示可以在其上執行一個或多個操作的元素序列。流操作是中間或終端。當終端操作返回一個特定類型的結果時，中間操作返回流本身，所以你可以鏈接多個方法調用。流在源上創建，例如一個 java.util.Collection 像列表或集合（不支持映射）。流操作既可以按順序執行，也可以並行執行。

流是非常強大的，所以，我寫了一個獨立的 Java 8 Streams 教程。您還應該查看 Sequent，將其作為 Web 的類似庫。

我們先來看看順序流如何工作。首先，我們以字符串列表的形式創建一個示例源代碼：

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() 來簡單地創建流。以下各節介紹最常見的流操作。

Filter

過濾器接受一個謂詞來過濾流的所有元素。這個操作是中間的，使我們能夠調用另一個流操作（forEach）的結果。 ForEach 接受一個消費者被執行的過濾流中的每個元素。 ForEach 是一個終端操作。它是無效的，所以我們不能調用另一個流操作。

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

// "aaa2", "aaa1"

Sorted

排序是一個中間操作，返回流的排序視圖。元素按自然順序排序，除非您傳遞自定義比較器。

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

// "aaa1", "aaa2"

請記住，排序只會創建流的排序視圖，而不會操縱支持的集合的排序。 stringCollection 的排序是不變的：

System.out.println(stringCollection);
// ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1

Map

中間操作映射通過給定函數將每個元素轉換為另一個對象。以下示例將每個字符串轉換為大寫字母字符串。但是您也可以使用 map 將每個對象轉換為另一種類型。結果流的泛型類型取決於您傳遞給 map 的函數的泛型類型。

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

// "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1"

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

Count 是一個終端操作，返回流中元素的個數。

long startsWithB =
    stringCollection
        .stream()
        .filter((s) -> s.startsWith("b"))
        .count();

System.out.println(startsWithB);    // 3

Reduce

該終端操作使用給定的功能對流的元素進行縮減。結果是一個 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

如上所述，流可以是順序的也可以是並行的。順序流上的操作在單個線程上執行，而並行流上的操作在多個線程上同時執行。

以下示例演示了通過使用並行流提高性能是多麽容易。

首先，我們創建一個較大的獨特元素的列表：

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

現在我們測量對這個集合進行排序所花費的時間。

Sequential Sort

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

// sequential sort took: 899 ms

Parallel Sort

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

// parallel sort took: 472 ms

如你所見，兩個代碼段差不多，但是並行排序快了近 50%。你所需做的僅僅是將 stream() 改為 parallelStream() 。

Maps

如前所述，map 不直接支持流。Map 接口本身沒有可用的 stream() 方法，但是你可以通過 map.keySet().stream() 、 map.values().stream() 和 map.entrySet().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 接受消費者為 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.remove(3, "val3");
map.get(3);             // val33

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

另一個有用方法：

map.getOrDefault(42, "not found");  // not found

合並一個 map 的 entry 很簡單：

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

如果不存在該鍵的條目，合並或者將鍵/值放入 map 中；否則將調用合並函數來更改現有值。

Date API

Java 8在 java.time 包下新增了一個全新的日期和時間 API。新的日期 API 與 Joda-Time 庫相似，但不一樣。以下示例涵蓋了此新API的最重要部分。

Clock

Clock 提供對當前日期和時間的訪問。Clock 知道一個時區，可以使用它來代替 System.currentTimeMillis() ，獲取從 Unix EPOCH 開始的以毫秒為單位的當前時間。時間線上的某一時刻也由類 Instant 表示。 Instants 可以用來創建遺留的 java.util.Date 對象。

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

Instant instant = clock.instant();
Date legacyDate = Date.from(instant);   // legacy 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 點或 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

LocalDate

LocalDate 表示不同的日期，例如：2014年3月11日。它是不可變的，並且與 LocalTime 完全類似。該示例演示如何通過加減日、月或年來計算新日期。請記住，每個操作都會返回一個新的實例。

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

LocalDateTime

LocalDateTime 表示日期時間。它將日期和時間組合成一個實例。 LocalDateTime 是不可變的，其作用類似於 LocalTime 和 LocalDate。我們可以利用方法去獲取日期時間中某個單位的值。

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

通過一個時區的附加信息可以轉為一個實例。這個實例很容易轉為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

日期時間的格式化類似於 Date 或 Time。我們可以使用自定義模式創建格式化程序，而不是使用預定義的格式。

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 是不可變且線程安全的 。

更多關於日期格式化的內容可以參考這裏.

Annotations

Java 8 中的註釋是可重復的。讓我們直接看一個例子來解決這個問題。

首先，我們定義一個包含實際註釋數組的外層註釋：

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

@Repeatable(Hints.class)
@interface Hint {
    String value();
}

Java8 允許我們通過使用 @Repeatable 註解來引入多個同類型的註解。

Variant 1: 使用容器註解 (老套路)

@Hints({@Hint("hint1"), @Hint("hint2")})
class Person {}

Variant 2: 使用 repeatable 註解 (新套路)

@Hint("hint1")
@Hint("hint2")
class Person {}

使用場景2，Java 編譯器隱式地設置了 @Hints 註解。

這對於通過反射來讀取註解信息很重要。

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 ，它可以直接訪問所有 @Hint 註解。

此外，Java 8中的註釋使用擴展了兩個新的目標：

@Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
@interface MyAnnotation {}

JDK8 指南（譯）

-c 作用表現字母 lba param nonnull pri 消費者翻譯自 java8-tutorial 新特性 Default Methods for Interfaces(接口的默認方法) Java 8 使我們能夠通過使用 default 關鍵字將非抽象方法

JDK8 指南（譯）

新特性

Default Methods for Interfaces(接口的默認方法)

Lambda expressions(Lambda 表達式)

Functional Interfaces(函數接口)

Method and Constructor References(方法和構造器引用)

Lambda Scopes(Lambda 作用域)

Accessing local variables(訪問本地變量)

Accessing fields and static variables(訪問成員變量和靜態變量)

Accessing Default Interface Methods（訪問默認的接口方法）

Built-in Functional Interfaces(內置函數接口)

Predicates

Functions

Suppliers

Consumers

Comparators

Optionals

Streams

Filter

Sorted

Map

Match

Count

Reduce

Parallel Streams

Sequential Sort

Parallel Sort

Maps

Date API

Clock

Timezones

LocalTime

LocalDate

LocalDateTime

Annotations

Variant 1: 使用容器註解 (老套路)

Variant 2: 使用 repeatable 註解 (新套路)

相關推薦