JDK8 指南（译）
新特性
Default Methods for Interfaces(接口的默認方法)
Java 8 使我們能夠通過使用?default?關鍵字將非抽象方法實現(xiàn)添加到接口。這個功能也被稱為虛擬擴展方法。
這是我們的第一個例子：
interface Formula {double calculate(int a);default double sqrt(int a) {return Math.sqrt(a);} }除了抽象方法?calculate?，接口?Formula?還定義了默認方法?sqrt。具體類只需要執(zhí)行抽象方法計算。默認的方法?sqrt?可以用于開箱即用。
Formula formula = new Formula() {public double calculate(int a) {return sqrt(a * 100);} };formula.calculate(100); // 100.0 formula.sqrt(16); // 4.0Formula?被實現(xiàn)為一個匿名對象。代碼非常冗長：用于?sqrt(a * 100)?這樣簡單的計算的 6 行代碼。正如我們將在下一節(jié)中看到的，在 Java 8 中實現(xiàn)單個方法對象有更好的方法。
Lambda expressions(Lambda 表達式)
讓我們從一個簡單的例子來說明如何在以前版本的 Java 中對字符串列表進行排序：
List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");Collections.sort(names, new Comparator<String>() {public int compare(String a, String b) {return b.compareTo(a);} });靜態(tài)工具方法?Collections.sort?為了對指定的列表進行排序，接受一個列表和一個比較器。您會發(fā)現(xiàn)自己經常需要創(chuàng)建匿名比較器并將其傳遞給排序方法。
Java 8 使用更簡短的?lambda 表達式來避免常常創(chuàng)建匿名對象的問題：
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));列表現(xiàn)在有一個?sort?方法。此外，java 編譯器知道參數(shù)類型，所以你可以不指定入?yún)⒌臄?shù)據(jù)類型。讓我們深入探討如何使用 lambda 表達式。
Functional Interfaces(函數(shù)接口)
lambda 表達式如何適應 Java 的類型系統(tǒng)？每個 lambda 對應一個由接口指定的類型。一個所謂的函數(shù)接口必須包含一個抽象方法聲明。該類型的每個 lambda 表達式都將與此抽象方法匹配。由于默認方法不是抽象的，所以你可以自由地添加默認方法到你的函數(shù)接口。
只要保證接口僅包含一個抽象方法，就可以使用任意的接口作為lambda表達式。為確保您的接口符合要求，您應該添加?@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(方法和構造器引用)
上面的示例代碼可以通過使用靜態(tài)方法引用進一步簡化：
Converter<String, Integer> converter = Integer::valueOf; Integer converted = converter.convert("123"); System.out.println(converted); // 123Java 8 允許您通過?::?關鍵字傳遞方法或構造函數(shù)的引用。上面的例子展示了如何引用一個靜態(tài)方法。但是我們也可以引用對象方法：
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;} }接著，我們指定一個用于創(chuàng)建 Person 對象的 PersonFactory 接口。
interface PersonFactory<P extends Person> {P create(String firstName, String lastName); }我們不是手動實現(xiàn)工廠，而是通過構造引用將所有東西粘合在一起：
PersonFactory<Person> personFactory = Person::new; Person person = personFactory.create("Peter", "Parker");我們通過?Person::new?來創(chuàng)建一個 Person 構造器的引用。Java 編譯器會根據(jù)PersonFactory.create?的簽名自動匹配正確的構造器。
Lambda Scopes(Lambda 作用域)
從 lambda 表達式訪問外部作用域變量與匿名對象非常相似。您可以訪問本地外部作用域的常量以及實例的成員變量和靜態(tài)變量。
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(訪問成員變量和靜態(tài)變量)
與局部變量相比，我們既可以在 lambda 表達式中讀寫實例的成員變量，也可以讀寫實例的靜態(tài)變量。這種行為在匿名對象中是眾所周知的。
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（訪問默認的接口方法）
還記得第一節(jié)的 formula 例子嗎？?Formula?接口定義了一個默認方法?sqrt，它可以被每個 formula 實例（包括匿名對象）訪問。這個特性不適用于 lambda 表達式。
默認方法不能被 lambda 表達式訪問。下面的代碼不能編譯通過：
Formula formula = (a) -> sqrt(a * 100);Built-in Functional Interfaces(內置函數(shù)接口)
JDK 1.8 API 包含許多內置的功能接口。它們中的一些在較早的Java版本（比如?Comparator?或?Runnable）中是眾所周知的。這些現(xiàn)有的接口通過?@FunctionalInterfaceannotation?注解被擴展為支持 Lambda。
但是，Java 8 API 也提供了不少新的函數(shù)接口。其中一些新接口在?Google Guava?庫中是眾所周知的。即使您熟悉這個庫，也應該密切關注如何通過一些有用的方法擴展來擴展這些接口。
Predicates
Predicate?是只有一個參數(shù)的布爾值函數(shù)。該接口包含各種默認方法，用于將謂詞組合成復雜的邏輯術語（與、或、非）
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?接受一個參數(shù)并產生一個結果。可以使用默認方法將多個函數(shù)鏈接在一起（compose、andThen）。
Function<String, Integer> toInteger = Integer::valueOf; Function<String, String> backToString = toInteger.andThen(String::valueOf);backToString.apply("123"); // "123"Suppliers
Supplier?產生一個泛型結果。與?Function?不同，Supplier?不接受參數(shù)。
Supplier<Person> personSupplier = Person::new; personSupplier.get(); // new PersonConsumers
Consumer 表示要在一個輸入?yún)?shù)上執(zhí)行的操作。
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); // < 0Optionals
Optional?不是功能性接口，而是防止?NullPointerException?的好工具。這是下一節(jié)的一個重要概念，所以讓我們快速看看?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?表示可以在其上執(zhí)行一個或多個操作的元素序列。流操作是中間或終端。當終端操作返回一個特定類型的結果時，中間操作返回流本身，所以你可以鏈接多個方法調用。流在源上創(chuàng)建，例如一個?java.util.Collection?像列表或集合（不支持映射）。流操作既可以按順序執(zhí)行，也可以并行執(zhí)行。
流是非常強大的，所以，我寫了一個獨立的?Java 8 Streams 教程?。您還應該查看 Sequent，將其作為 Web 的類似庫。
我們先來看看順序流如何工作。首先，我們以字符串列表的形式創(chuàng)建一個示例源代碼：
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()?來簡單地創(chuàng)建流。以下各節(jié)介紹最常見的流操作。
Filter
過濾器接受一個謂詞來過濾流的所有元素。這個操作是中間的，使我們能夠調用另一個流操作（forEach）的結果。 ForEach 接受一個消費者被執(zhí)行的過濾流中的每個元素。 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"請記住，排序只會創(chuàng)建流的排序視圖，而不會操縱支持的集合的排序。?stringCollection?的排序是不變的：
System.out.println(stringCollection); // ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1Map
中間操作映射通過給定函數(shù)將每個元素轉換為另一個對象。以下示例將每個字符串轉換為大寫字母字符串。但是您也可以使用?map?將每個對象轉換為另一種類型。結果流的泛型類型取決于您傳遞給?map?的函數(shù)的泛型類型。
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); // trueCount
Count 是一個終端操作，返回流中元素的個數(shù)。
long startsWithB =stringCollection.stream().filter((s) -> s.startsWith("b")).count();System.out.println(startsWithB); // 3Reduce
該終端操作使用給定的功能對流的元素進行縮減。結果是一個?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
如上所述，流可以是順序的也可以是并行的。順序流上的操作在單個線程上執(zhí)行，而并行流上的操作在多個線程上同時執(zhí)行。
以下示例演示了通過使用并行流提高性能是多么容易。
首先，我們創(chuàng)建一個較大的獨特元素的列表：
int max = 1000000; List<String> values = new ArrayList<>(max); for (int i = 0; i < max; i++) {UUID uuid = UUID.randomUUID();values.add(uuid.toString()); }現(xiàn)在我們測量對這個集合進行排序所花費的時間。
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 msParallel 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()?創(chuàng)建指定的流。
此外，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 的每個值實現(xiàn)操作。
這個例子展示了如何利用函數(shù)來計算 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 中；否則將調用合并函數(shù)來更改現(xiàn)有值。
Date API
Java 8在?java.time?包下新增了一個全新的日期和時間 API。新的日期 API 與?Joda-Time?庫相似，但不一樣。以下示例涵蓋了此新API的最重要部分。
Clock
Clock?提供對當前日期和時間的訪問。Clock?知道一個時區(qū)，可以使用它來代替?System.currentTimeMillis()?，獲取從?Unix EPOCH?開始的以毫秒為單位的當前時間。時間線上的某一時刻也由類?Instant?表示。 Instants 可以用來創(chuàng)建遺留的?java.util.Date對象。
Clock clock = Clock.systemDefaultZone(); long millis = clock.millis();Instant instant = clock.instant(); Date legacyDate = Date.from(instant); // legacy java.util.DateTimezones
時區(qū)由?ZoneId?表示。他們可以很容易地通過靜態(tài)工廠方法訪問。時區(qū)定義了某一時刻和當?shù)厝掌凇r間之間轉換的重要偏移量。
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?代表沒有時區(qū)的時間，例如晚上 10 點或 17:30:15。以下示例為上面定義的時區(qū)創(chuàng)建兩個本地時間。然后我們比較兩次，并計算兩次之間的小時和分鐘的差異。
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); // -239LocalTime?帶有各種工廠方法，以簡化新實例的創(chuàng)建，包括解析時間字符串。
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:37LocalDate
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-24LocalDateTime
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通過一個時區(qū)的附加信息可以轉為一個實例。這個實例很容易轉為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。我們可以使用自定義模式創(chuàng)建格式化程序，而不是使用預定義的格式。
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 中的注釋是可重復的。讓我們直接看一個例子來解決這個問題。
首先，我們定義一個包含實際注釋數(shù)組的外層注釋：
@interface Hints {Hint[] value(); }@Repeatable(Hints.class) @interface Hint {String value(); }Java8 允許我們通過使用?@Repeatable?注解來引入多個同類型的注解。
Variant 1: 使用容器注解 (老套路)
({("hint1"), ("hint2")}) class Person {}Variant 2: 使用 repeatable 注解 (新套路)
("hint1") ("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中的注釋使用擴展了兩個新的目標：
({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE}) MyAnnotation {}本文轉自靜默虛空博客園博客，原文鏈接：http://www.cnblogs.com/jingmoxukong/p/7833699.html，如需轉載請自行聯(lián)系原作者總結
以上是生活随笔為你收集整理的JDK8 指南（译）的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： LBS突围：从微信到微博
- 下一篇： 生产环境子域降级记录