Java 8新特性終極指南
編者注：Java 8已經公布有一段時間了，種種跡象表明Java 8是一個有重大改變的發行版。
在Java Code Geeks上已經有大量的關於Java 8 的教程了，像玩轉Java 8——lambda與並發，Java 8 Date Time API 教程： LocalDateTime和在Java 8中抽象類與接口的比較。
我們也在其他地方引用了15個必讀的Java 8教程。當然，我們也探究了Java 8的一些不足之處，比如Java 8的“黑暗面”。
現在，是時候把所有Java 8的重要特性收集整理成一篇單獨的文章了，希望這篇文章能給你帶來閱讀上的樂趣。開始吧！
目錄結構
- 介紹
- Java語言的新特性
2.2 接口的默認與靜態方法
2.3 方法引用
2.4 重復注解
2.5 更好的類型推測機制
2.6 擴展注解的支持
- Java編譯器的新特性
3.1 參數名字
- Java 類庫的新特性
4.1 Optional
4.2 Streams
4.5 Base64
4.6 並行（parallel）數組
4.7 並發（Concurrency）
- 新增的Java工具
5.1 Nashorn引擎: jjs
5.2 類依賴分析器: jdeps
1.介紹
毫無疑問，Java 8發行版是自Java 5（發行於2004，已經過了相當一段時間了）以來最具革命性的版本。Java 8 為Java語言、編譯器、類庫、開發工具與JVM（Java虛擬機）帶來了大量新特性。在這篇教程中，我們將一一探索這些變化，並用真實的例子說明它們適用的場景。
這篇教程由以下幾部分組成，它們分別涉及到Java平台某一特定方面的內容：
- Java語言
- 編譯器
- 類庫
- 工具
- Java運行時（JVM）
2.Java語言的新特性
不管怎么說，Java 8都是一個變化巨大的版本。你可能認為Java 8耗費了大量的時間才得以完成是為了實現了每個Java程序員所期待的特性。在這個小節里，我們將會涉及到這些特性的大部分。
2.1 Lambda表達式與Functional接口
Lambda表達式（也稱為閉包）是整個Java 8發行版中最受期待的在Java語言層面上的改變，Lambda允許把函數作為一個方法的參數（函數作為參數傳遞進方法中），或者把代碼看成數據：函數式程序員對這一概念非常熟悉。在JVM平台上的很多語言（Groovy，Scala，……）從一開始就有Lambda，但是Java程序員不得不使用毫無新意的匿名類來代替lambda。
關於Lambda設計的討論占用了大量的時間與社區的努力。可喜的是，最終找到了一個平衡點，使得可以使用一種即簡潔又緊湊的新方式來構造Lambdas。在最簡單的形式中，一個lambda可以由用逗號分隔的參數列表、–>符號與函數體三部分表示。例如：
|
1
|
Arrays.asList(
"a"
,
"b"
,
"d"
).forEach( e -> System.out.println( e ) );
|
請注意參數e的類型是由編譯器推測出來的。同時，你也可以通過把參數類型與參數包括在括號中的形式直接給出參數的類型：
|
1
|
Arrays.asList(
"a"
,
"b"
,
"d"
).forEach( ( String e ) -> System.out.println( e ) );
|
在某些情況下lambda的函數體會更加復雜，這時可以把函數體放到在一對花括號中，就像在Java中定義普通函數一樣。例如：
|
1
2
3
4
|
Arrays.asList(
"a"
,
"b"
,
"d"
).forEach( e -> {
System.out.print( e );
System.out.print( e );
} );
|
Lambda可以引用類的成員變量與局部變量（如果這些變量不是final的話，它們會被隱含的轉為final，這樣效率更高）。例如，下面兩個代碼片段是等價的：
|
1
2
3
|
String separator =
","
;
Arrays.asList(
"a"
,
"b"
,
"d"
).forEach(
( String e ) -> System.out.print( e + separator ) );
|
和：
|
1
2
3
|
final
String separator =
","
;
Arrays.asList(
"a"
,
"b"
,
"d"
).forEach(
( String e ) -> System.out.print( e + separator ) );
|
Lambda可能會返回一個值。返回值的類型也是由編譯器推測出來的。如果lambda的函數體只有一行的話，那么沒有必要顯式使用return語句。下面兩個代碼片段是等價的：
|
1
|
Arrays.asList(
"a"
,
"b"
,
"d"
).sort( ( e1, e2 ) -> e1.compareTo( e2 ) );
|
和：
|
1
2
3
4
|
Arrays.asList(
"a"
,
"b"
,
"d"
).sort( ( e1, e2 ) -> {
int
result = e1.compareTo( e2 );
return
result;
} );
|
語言設計者投入了大量精力來思考如何使現有的函數友好地支持lambda。最終采取的方法是：增加函數式接口的概念。函數式接口就是一個具有一個方法的普通接口。像這樣的接口，可以被隱式轉換為lambda表達式。java.lang.Runnable與java.util.concurrent.Callable是函數式接口最典型的兩個例子。在實際使用過程中，函數式接口是容易出錯的：如有某個人在接口定義中增加了另一個方法，這時，這個接口就不再是函數式的了，並且編譯過程也會失敗。為了克服函數式接口的這種脆弱性並且能夠明確聲明接口作為函數式接口的意圖，Java 8增加了一種特殊的注解@FunctionalInterface（Java 8中所有類庫的已有接口都添加了@FunctionalInterface注解）。讓我們看一下這種函數式接口的定義：
|
1
2
3
4
|
@FunctionalInterface
public
interface
Functional {
void
method();
}
|
需要記住的一件事是：默認方法與靜態方法並不影響函數式接口的契約，可以任意使用：
|
1
2
3
4
5
6
7
|
@FunctionalInterface
public
interface
FunctionalDefaultMethods {
void
method();
default
void
defaultMethod() {
}
}
|
Lambda是Java 8最大的賣點。它具有吸引越來越多程序員到Java平台上的潛力，並且能夠在純Java語言環境中提供一種優雅的方式來支持函數式編程。更多詳情可以參考官方文檔。
2.2 接口的默認方法與靜態方法
Java 8用默認方法與靜態方法這兩個新概念來擴展接口的聲明。默認方法使接口有點像Traits（Scala中特征(trait)類似於Java中的Interface，但它可以包含實現代碼，也就是目前Java8新增的功能），但與傳統的接口又有些不一樣，它允許在已有的接口中添加新方法，而同時又保持了與舊版本代碼的兼容性。
默認方法與抽象方法不同之處在於抽象方法必須要求實現，但是默認方法則沒有這個要求。相反，每個接口都必須提供一個所謂的默認實現，這樣所有的接口實現者將會默認繼承它（如果有必要的話，可以覆蓋這個默認實現）。讓我們看看下面的例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
private
interface
Defaulable {
// Interfaces now allow default methods, the implementer may or
// may not implement (override) them.
default
String notRequired() {
return
"Default implementation"
;
}
}
private
static
class
DefaultableImpl
implements
Defaulable {
}
private
static
class
OverridableImpl
implements
Defaulable {
@Override
public
String notRequired() {
return
"Overridden implementation"
;
}
}
|
Defaulable接口用關鍵字default聲明了一個默認方法notRequired()，Defaulable接口的實現者之一DefaultableImpl實現了這個接口，並且讓默認方法保持原樣。Defaulable接口的另一個實現者OverridableImpl用自己的方法覆蓋了默認方法。
Java 8帶來的另一個有趣的特性是接口可以聲明（並且可以提供實現）靜態方法。例如：
|
1
2
3
4
5
6
|
private
interface
DefaulableFactory {
// Interfaces now allow static methods
static
Defaulable create( Supplier< Defaulable > supplier ) {
return
supplier.get();
}
}
|
下面的一小段代碼片段把上面的默認方法與靜態方法黏合到一起。
|
1
2
3
4
5
6
7
|
public
static
void
main( String[] args ) {
Defaulable defaulable = DefaulableFactory.create( DefaultableImpl::
new
);
System.out.println( defaulable.notRequired() );
defaulable = DefaulableFactory.create( OverridableImpl::
new
);
System.out.println( defaulable.notRequired() );
}
|
這個程序的控制台輸出如下：
|
1
2
|
Default implementation
Overridden implementation
|
在JVM中，默認方法的實現是非常高效的，並且通過字節碼指令為方法調用提供了支持。默認方法允許繼續使用現有的Java接口，而同時能夠保障正常的編譯過程。這方面好的例子是大量的方法被添加到java.util.Collection接口中去：stream()，parallelStream()，forEach()，removeIf()，……
盡管默認方法非常強大，但是在使用默認方法時我們需要小心注意一個地方：在聲明一個默認方法前，請仔細思考是不是真的有必要使用默認方法，因為默認方法會帶給程序歧義，並且在復雜的繼承體系中容易產生編譯錯誤。更多詳情請參考官方文檔
2.3 方法引用
方法引用提供了非常有用的語法，可以直接引用已有Java類或對象（實例）的方法或構造器。與lambda聯合使用，方法引用可以使語言的構造更緊湊簡潔，減少冗余代碼。
下面，我們以定義了4個方法的Car這個類作為例子，區分Java中支持的4種不同的方法引用。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public
static
class
Car {
public
static
Car create(
final
Supplier< Car > supplier ) {
return
supplier.get();
}
public
static
void
collide(
final
Car car ) {
System.out.println(
"Collided "
+ car.toString() );
}
public
void
follow(
final
Car another ) {
System.out.println(
"Following the "
+ another.toString() );
}
public
void
repair() {
System.out.println(
"Repaired "
+
this
.toString() );
}
}
|
第一種方法引用是構造器引用，它的語法是Class::new，或者更一般的Class< T >::new。請注意構造器沒有參數。
|
1
2
|
final
Car car = Car.create( Car::
new
);
final
List< Car > cars = Arrays.asList( car );
|
第二種方法引用是靜態方法引用，它的語法是Class::static_method。請注意這個方法接受一個Car類型的參數。
|
1
|
cars.forEach( Car::collide );
|
第三種方法引用是特定類的任意對象的方法引用，它的語法是Class::method。請注意，這個方法沒有參數。
|
1
|
cars.forEach( Car::repair );
|
最后，第四種方法引用是特定對象的方法引用，它的語法是instance::method。請注意，這個方法接受一個Car類型的參數
|
1
2
|
final
Car police = Car.create( Car::
new
);
cars.forEach( police::follow );
|
運行上面的Java程序在控制台上會有下面的輸出（Car的實例可能不一樣）：
|
1
2
3
|
Collided com.javacodegeeks.java8.method.references.MethodReferences$Car
@7a81197d
Repaired com.javacodegeeks.java8.method.references.MethodReferences$Car
@7a81197d
Following the com.javacodegeeks.java8.method.references.MethodReferences$Car
@7a81197d
|
關於方法引用的更多詳情請參考官方文檔。
2.4 重復注解
自從Java 5引入了注解機制，這一特性就變得非常流行並且廣為使用。然而，使用注解的一個限制是相同的注解在同一位置只能聲明一次，不能聲明多次。Java 8打破了這條規則，引入了重復注解機制，這樣相同的注解可以在同一地方聲明多次。
重復注解機制本身必須用@Repeatable注解。事實上，這並不是語言層面上的改變，更多的是編譯器的技巧，底層的原理保持不變。讓我們看一個快速入門的例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
package
com.javacodegeeks.java8.repeatable.annotations;
import
java.lang.annotation.ElementType;
import
java.lang.annotation.Repeatable;
import
java.lang.annotation.Retention;
import
java.lang.annotation.RetentionPolicy;
import
java.lang.annotation.Target;
public
class
RepeatingAnnotations {
@Target
( ElementType.TYPE )
@Retention
( RetentionPolicy.RUNTIME )
public
@interface
Filters {
Filter[] value();
}
@Target
( ElementType.TYPE )
@Retention
( RetentionPolicy.RUNTIME )
@Repeatable
( Filters.
class
)
public
@interface
Filter {
String value();
};
@Filter
(
"filter1"
)
@Filter
(
"filter2"
)
public
interface
Filterable {
}
public
static
void
main(String[] args) {
for
( Filter filter: Filterable.
class
.getAnnotationsByType( Filter.
class
) ) {
System.out.println( filter.value() );
}
}
}
|
正如我們看到的，這里有個使用@Repeatable( Filters.class )注解的注解類Filter，Filters僅僅是Filter注解的數組，但Java編譯器並不想讓程序員意識到Filters的存在。這樣，接口Filterable就擁有了兩次Filter（並沒有提到Filter）注解。
同時，反射相關的API提供了新的函數getAnnotationsByType()來返回重復注解的類型（請注意Filterable.class.getAnnotation( Filters.class )經編譯器處理后將會返回Filters的實例）。
程序輸出結果如下：
|
1
2
|
filter1
filter2
|
更多詳情請參考官方文檔
2.5 更好的類型推測機制
Java 8在類型推測方面有了很大的提高。在很多情況下，編譯器可以推測出確定的參數類型，這樣就能使代碼更整潔。讓我們看一個例子：
|
1
2
3
4
5
6
7
8
9
10
11
|
package
com.javacodegeeks.java8.type.inference;
public
class
Value< T > {
public
static
< T > T defaultValue() {
return
null
;
}
public
T getOrDefault( T value, T defaultValue ) {
return
( value !=
null
) ? value : defaultValue;
}
}
|
這里是Value< String >類型的用法。
|
1
2
3
4
5
6
7
8
|
package
com.javacodegeeks.java8.type.inference;
public
class
TypeInference {
public
static
void
main(String[] args) {
final
Value< String > value =
new
Value<>();
value.getOrDefault(
"22"
, Value.defaultValue() );
}
}
|
Value.defaultValue()的參數類型可以被推測出，所以就不必明確給出。在Java 7中，相同的例子將不會通過編譯，正確的書寫方式是 Value.< String >defaultValue()。
2.6 擴展注解的支持
Java 8擴展了注解的上下文。現在幾乎可以為任何東西添加注解：局部變量、泛型類、父類與接口的實現，就連方法的異常也能添加注解。下面演示幾個例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
package
com.javacodegeeks.java8.annotations;
import
java.lang.annotation.ElementType;
import
java.lang.annotation.Retention;
import
java.lang.annotation.RetentionPolicy;
import
java.lang.annotation.Target;
import
java.util.ArrayList;
import
java.util.Collection;
public
class
Annotations {
@Retention
( RetentionPolicy.RUNTIME )
@Target
( { ElementType.TYPE_USE, ElementType.TYPE_PARAMETER } )
public
@interface
NonEmpty {
}
public
static
class
Holder<
@NonEmpty
T >
extends
@NonEmpty
Object {
public
void
method()
throws
@NonEmpty
Exception {
}
}
@SuppressWarnings
(
"unused"
)
public
static
void
main(String[] args) {
final
Holder< String > holder =
new
@NonEmpty
Holder< String >();
@NonEmpty
Collection<
@NonEmpty
String > strings =
new
ArrayList<>();
}
}
|
ElementType.TYPE_USE和ElementType.TYPE_PARAMETER是兩個新添加的用於描述適當的注解上下文的元素類型。在Java語言中，注解處理API也有小的改動來識別新增的類型注解。