新特性

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() {@Overridepublic 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>() {@Overridepublic 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"); // falsePredicate<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); // trueboolean allStartsWithA =stringCollection.stream().allMatch((s) -> s.startsWith("a"));System.out.println(allStartsWithA); // falseboolean 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); // val33map.computeIfPresent(9, (num, val) -> null); map.containsKey(9); // falsemap.computeIfAbsent(23, num -> "val" + num); map.containsKey(23); // truemap.computeIfAbsent(3, num -> "bam"); map.get(3); // val33

接下來，我們學習如何刪除給定鍵的條目，只有當前鍵映射到給定值時：

map.remove(3, "val3"); map.get(3); // val33map.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); // val9map.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 idsZoneId 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)); // falselong 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:59DateTimeFormatter 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); // WEDNESDAYMonth month = sylvester.getMonth(); System.out.println(month); // DECEMBERlong 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); // nullHints hints1 = Person.class.getAnnotation(Hints.class); System.out.println(hints1.value().length); // 2Hint[] 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 {}本文轉自靜默虛空博客園博客，原文鏈接：http://www.cnblogs.com/jingmoxukong/p/7833699.html，如需轉載請自行聯系原作者

總結

以上是生活随笔為你收集整理的JDK8 指南（译）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。