[轉載] Java9發布回顧Java 8的十大新特性

參考鏈接： Java中的DoubleStream mapToObj()

java9已經在北京時間9月22日正式發布，開發者可以在oracle jdk官網上下載到最新的jdk9。?

今天，我們先來一起復習一下2014年發布的Java 8的十大新特性。先來喝杯java~~~?

按照java升級的傳統，偶數版的（468）改動較小，奇數版的（579）都是大改動。但對于java8而言是一次變化巨大的更新，耗費了工程師大量的時間，還借鑒了很多其它語言和類庫。這里為大家列舉十個新特性。? ?

?Lambda表達式??

?Lambda表達式（也稱為閉包）是整個Java 8發行版中最受期待的在Java語言層面上的改變，Lambda允許把函數作為一個方法的參數（函數作為參數傳遞進方法中），或者把代碼看成數據：函數式程序員對這一概念非常熟悉。在JVM平臺上的很多語言（Groovy，Scala，……）從一開始就有Lambda，但是Java程序員不得不使用毫無新意的匿名類來代替lambda。? 關于Lambda設計的討論占用了大量的時間與社區的努力。可喜的是，最終找到了一個平衡點，使得可以使用一種即簡潔又緊湊的新方式來構造Lambdas。在最簡單的形式中，一個lambda可以由用逗號分隔的參數列表、–>符號與函數體三部分表示。例如：??

Arrays.asList( "a", "b", "d" ).forEach( e -> System.out.println( e ) );

請注意參數e的類型是由編譯器推測出來的。同時，你也可以通過把參數類型與參數包括在括號中的形式直接給出參數的類型：?

Arrays.asList( "a", "b", "d" ).forEach( ( String e ) -> System.out.println( e ) );

在某些情況下lambda的函數體會更加復雜，這時可以把函數體放到在一對花括號中，就像在Java中定義普通函數一樣。例如：?

Arrays.asList( "a", "b", "d" ).forEach( e -> {

? ? System.out.print( e );

} );

?Lambda可以引用類的成員變量與局部變量（如果這些變量不是final的話，它們會被隱含的轉為final，這樣效率更高）。例如，下面兩個代碼片段是等價的：

String separator = ",";

Arrays.asList( "a", "b", "d" ).forEach(?

? ? ( String e ) -> System.out.print( e + separator ) );

final String separator = ",";

Arrays.asList( "a", "b", "d" ).forEach(?

? ? ( String e ) -> System.out.print( e + separator ) );

Lambda可能會返回一個值。返回值的類型也是由編譯器推測出來的。如果lambda的函數體只有一行的話，那么沒有必要顯式使用return語句。下面兩個代碼片段是等價的：?

Arrays.asList( "a", "b", "d" ).sort( ( e1, e2 ) -> e1.compareTo( e2 ) );

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注解）。讓我們看一下這種函數式接口的定義：

@FunctionalInterface

public interface Functional {

? ? void method();

}

需要記住的一件事是：

默認方法與靜態方法

并不影響函數式接口的契約，可以任意使用：

@FunctionalInterface

public interface FunctionalDefaultMethods {

? ? void method();

? ? ? ? ?

? ? default void defaultMethod() {? ? ? ? ? ??

? ? }? ? ? ??

}

Lambda是Java 8最大的賣點。它具有吸引越來越多程序員到Java平臺上的潛力，并且能夠在純Java語言環境中提供一種優雅的方式來支持函數式編程。更多詳情可以參考官方文檔。?

?接口的默認方法與靜態方法??

?Java 8用默認方法與靜態方法這兩個新概念來擴展接口的聲明。默認方法使接口有點像Traits（Scala中特征(trait)類似于Java中的Interface，但它可以包含實現代碼，也就是目前Java8新增的功能），但與傳統的接口又有些不一樣，它允許在已有的接口中添加新方法，而同時又保持了與舊版本代碼的兼容性。?

?默認方法與抽象方法不同之處在于抽象方法必須要求實現，但是默認方法則沒有這個要求。相反，每個接口都必須提供一個所謂的默認實現，這樣所有的接口實現者將會默認繼承它（如果有必要的話，可以覆蓋這個默認實現）。讓我們看看下面的例子：??

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帶來的另一個有趣的特性是接口可以聲明（并且可以提供實現）靜態方法。例如：??

private interface DefaulableFactory {

? ? // Interfaces now allow static methods

? ? static Defaulable create( Supplier< Defaulable > supplier ) {

? ? ? ? return supplier.get();

? ? }

}

下面的一小段代碼片段把上面的默認方法與靜態方法黏合到一起：?

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

}

這個程序的控制臺輸出如下：

Default implementation

Overridden implementation

在JVM中，默認方法的實現是非常高效的，并且通過字節碼指令為方法調用提供了支持。默認方法允許繼續使用現有的Java接口，而同時能夠保障正常的編譯過程。這方面好的例子是大量的方法被添加到java.util.Collection接口中去：stream()，parallelStream()，forEach()，removeIf()，……?

盡管默認方法非常強大，但是在使用默認方法時我們需要小心注意一個地方：在聲明一個默認方法前，請仔細思考是不是真的有必要使用默認方法，因為默認方法會帶給程序歧義，并且在復雜的繼承體系中容易產生編譯錯誤。更多詳情請參考

官方文檔

?Stream??

?最新添加的Stream API（java.util.stream）把真正的函數式編程風格引入到Java中。這是目前為止對Java類庫最好的補充，因為Stream API可以極大提供Java程序員的生產力，讓程序員寫出高效率、干凈、簡潔的代碼。?

?Stream API極大簡化了集合框架的處理（但它的處理的范圍不僅僅限于集合框架的處理，這點后面我們會看到）。讓我們以一個簡單的Task類為例進行介紹：??

public class Streams? {

? ? private enum Status {

? ? ? ? OPEN, CLOSED

? ? };

? ? ?

? ? private static final class Task {

? ? ? ? private final Status status;

? ? ? ? private final Integer points;

? ? ? ? Task( final Status status, final Integer points ) {

? ? ? ? ? ? this.status = status;

? ? ? ? ? ? this.points = points;

? ? ? ? }

? ? ? ? ?

? ? ? ? public Integer getPoints() {

? ? ? ? ? ? return points;

? ? ? ? }

? ? ? ? ?

? ? ? ? public Status getStatus() {

? ? ? ? ? ? return status;

? ? ? ? }

? ? ? ? ?

? ? ? ? @Override

? ? ? ? public String toString() {

? ? ? ? ? ? return String.format( "[%s, %d]", status, points );

? ? ? ? }

? ? }

}

Task類有一個分數的概念（或者說是偽復雜度），其次是還有一個值可以為OPEN或CLOSED的狀態.讓我們引入一個Task的小集合作為演示例子：?

final Collection< Task > tasks = Arrays.asList(

? ? new Task( Status.OPEN, 5 ),

? ? new Task( Status.OPEN, 13 ),

? ? new Task( Status.CLOSED, 8 )?

);

我們下面要討論的第一個問題是所有狀態為OPEN的任務一共有多少分數？在Java 8以前，一般的解決方式用foreach循環，但是在Java 8里面我們可以使用stream：一串支持連續、并行聚集操作的元素。?

// Calculate total points of all active tasks using sum()

final long totalPointsOfOpenTasks = tasks

? ? .stream()

? ? .filter( task -> task.getStatus() == Status.OPEN )

? ? .mapToInt( Task::getPoints )

? ? .sum();

? ? ? ? ?

System.out.println( "Total points: " + totalPointsOfOpenTasks );

程序在控制臺上的輸出如下：?

Total points: 18?

?這里有幾個注意事項。第一，task集合被轉換化為其相應的stream表示。然后，filter操作過濾掉狀態為CLOSED的task。下一步，mapToInt操作通過Task::getPoints這種方式調用每個task實例的getPoints方法把Task的stream轉化為Integer的stream。最后，用sum函數把所有的分數加起來，得到最終的結果。?

?在繼續講解下面的例子之前，關于stream有一些需要注意的地方（詳情在這里）.stream操作被分成了中間操作與最終操作這兩種。?

?中間操作返回一個新的stream對象。中間操作總是采用惰性求值方式，運行一個像filter這樣的中間操作實際上沒有進行任何過濾，相反它在遍歷元素時會產生了一個新的stream對象，這個新的stream對象包含原始stream 中符合給定謂詞的所有元素。?

?像forEach、sum這樣的最終操作可能直接遍歷stream，產生一個結果或副作用。當最終操作執行結束之后，stream管道被認為已經被消耗了，沒有可能再被使用了。在大多數情況下，最終操作都是采用及早求值方式，及早完成底層數據源的遍歷。?

?stream另一個有價值的地方是能夠原生支持并行處理。讓我們來看看這個算task分數和的例子。??

// Calculate total points of all tasks

final double totalPoints = tasks

? ?.stream()

? ?.parallel()

? ?.map( task -> task.getPoints() ) // or map( Task::getPoints )?

? ?.reduce( 0, Integer::sum );

? ? ?

System.out.println( "Total points (all tasks): " + totalPoints );

這個例子和第一個例子很相似，但這個例子的不同之處在于這個程序是并行運行的，其次使用reduce方法來算最終的結果。

下面是這個例子在控制臺的輸出：?

Total points (all tasks): 26.0

經常會有這個一個需求：我們需要按照某種準則來對集合中的元素進行分組。Stream也可以處理這樣的需求，下面是一個例子：?

// Group tasks by their status

final Map< Status, List< Task > > map = tasks

? ? .stream()

? ? .collect( Collectors.groupingBy( Task::getStatus ) );

System.out.println( map );

這個例子的控制臺輸出如下：?

{CLOSED=[[CLOSED, 8]], OPEN=[[OPEN, 5], [OPEN, 13]]}

讓我們來計算整個集合中每個task分數（或權重）的平均值來結束task的例子。?

// Calculate the weight of each tasks (as percent of total points)?

final Collection< String > result = tasks

? ? .stream()? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? // Stream< String >

? ? .mapToInt( Task::getPoints )? ? ? ? ? ? ? ? ? ? ?// IntStream

? ? .asLongStream()? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? // LongStream

? ? .mapToDouble( points -> points / totalPoints )? ?// DoubleStream

? ? .boxed()? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?// Stream< Double >

? ? .mapToLong( weigth -> ( long )( weigth * 100 ) ) // LongStream

? ? .mapToObj( percentage -> percentage + "%" )? ? ? // Stream< String>?

? ? .collect( Collectors.toList() );? ? ? ? ? ? ? ? ?// List< String >?

? ? ? ? ?

System.out.println( result );

下面是這個例子的控制臺輸出：?

[19%, 50%, 30%]

最后，就像前面提到的，Stream API不僅僅處理Java集合框架。像從文本文件中逐行讀取數據這樣典型的I/O操作也很適合用Stream API來處理。下面用一個例子來應證這一點。?

final Path path = new File( filename ).toPath();

try( Stream< String > lines = Files.lines( path, StandardCharsets.UTF_8 ) ) {

? ? lines.onClose( () -> System.out.println("Done!") ).forEach( System.out::println );

?對一個stream對象調用onClose方法會返回一個在原有功能基礎上新增了關閉功能的stream對象，當對stream對象調用close()方法時，與關閉相關的處理器就會執行。?

?Stream API、Lambda表達式與方法引用在接口默認方法與靜態方法的配合下是Java 8對現代軟件開發范式的回應。更多詳情請參考官方文檔。?

? ?

?Date/Time API (JSR 310)??

?Java 8通過發布新的Date-Time API (JSR 310)來進一步加強對日期與時間的處理。對日期與時間的操作一直是Java程序員最痛苦的地方之一。標準的 java.util.Date以及后來的java.util.Calendar一點沒有改善這種情況（可以這么說，它們一定程度上更加復雜）。?

?這種情況直接導致了Joda-Time——一個可替換標準日期/時間處理且功能非常強大的Java API的誕生。Java 8新的Date-Time API (JSR 310)在很大程度上受到Joda-Time的影響，并且吸取了其精髓。新的java.time包涵蓋了所有處理日期，時間，日期/時間，時區，時刻（instants），過程（during）與時鐘（clock）的操作。在設計新版API時，十分注重與舊版API的兼容性：不允許有任何的改變（從java.util.Calendar中得到的深刻教訓）。如果需要修改，會返回這個類的一個新實例。?

?讓我們用例子來看一下新版API主要類的使用方法。第一個是Clock類，它通過指定一個時區，然后就可以獲取到當前的時刻，日期與時間。Clock可以替換System.currentTimeMillis()與TimeZone.getDefault()。??

// Get the system clock as UTC offset?

final Clock clock = Clock.systemUTC();

System.out.println( clock.instant() );

System.out.println( clock.millis() );

下面是程序在控制臺上的輸出：

2014-04-12T15:19:29.282Z

1397315969360

我們需要關注的其他類是LocaleDate與LocalTime。LocaleDate只持有ISO-8601格式且無時區信息的日期部分。相應的，LocaleTime只持有ISO-8601格式且無時區信息的時間部分。LocaleDate與LocalTime都可以從Clock中得到。

// Get the local date and local time

final LocalDate date = LocalDate.now();

final LocalDate dateFromClock = LocalDate.now( clock );

? ? ? ? ?

System.out.println( date );

System.out.println( dateFromClock );

? ? ? ? ?

// Get the local date and local time

final LocalTime time = LocalTime.now();

final LocalTime timeFromClock = LocalTime.now( clock );

? ? ? ? ?

System.out.println( time );

System.out.println( timeFromClock );

下面是程序在控制臺上的輸出：

2014-04-12

11:25:54.568

15:25:54.568

LocaleDateTime把LocaleDate與LocaleTime的功能合并起來，它持有的是ISO-8601格式無時區信息的日期與時間。下面是一個

快速入門

的例子。

// Get the local date/time

final LocalDateTime datetime = LocalDateTime.now();

final LocalDateTime datetimeFromClock = LocalDateTime.now( clock );

? ? ? ? ?

System.out.println( datetime );

System.out.println( datetimeFromClock );

下面是程序在控制臺上的輸出：

2014-04-12T11:37:52.309

2014-04-12T15:37:52.309

如果你需要特定時區的日期/時間，那么ZonedDateTime是你的選擇。它持有ISO-8601格式具具有時區信息的日期與時間。下面是一些不同時區的例子：

// Get the zoned date/time

final ZonedDateTime zonedDatetime = ZonedDateTime.now();

final ZonedDateTime zonedDatetimeFromClock = ZonedDateTime.now( clock );

final ZonedDateTime zonedDatetimeFromZone = ZonedDateTime.now( ZoneId.of( "America/Los_Angeles" ) );

? ? ? ? ?

System.out.println( zonedDatetime );

System.out.println( zonedDatetimeFromClock );

System.out.println( zonedDatetimeFromZone );

下面是程序在控制臺上的輸出：

2014-04-12T11:47:01.017-04:00[America/New_York]

2014-04-12T15:47:01.017Z

2014-04-12T08:47:01.017-07:00[America/Los_Angeles]

最后，讓我們看一下Duration類：在秒與納秒級別上的一段時間。Duration使計算兩個日期間的不同變的十分簡單。下面讓我們看一個這方面的例子。

// Get duration between two dates

final LocalDateTime from = LocalDateTime.of( 2014, Month.APRIL, 16, 0, 0, 0 );

final LocalDateTime to = LocalDateTime.of( 2015, Month.APRIL, 16, 23, 59, 59 );

final Duration duration = Duration.between( from, to );

System.out.println( "Duration in days: " + duration.toDays() );

System.out.println( "Duration in hours: " + duration.toHours() );

上面的例子計算了兩個日期2014年4月16號與2014年4月16號之間的過程。下面是程序在控制臺上的輸出：

Duration in days: 365

Duration in hours: 8783?

對Java 8在日期/時間API的改進整體印象是非常非常好的。一部分原因是因為它建立在“久戰殺場”的Joda-Time基礎上，另一方面是因為用來大量的時間來設計它，并且這次程序員的聲音得到了認可。更多詳情請參考官方文檔。?

?擴展注解的支持??

Java 8擴展了注解的上下文。現在幾乎可以為任何東西添加注解：局部變量、泛型類、父類與接口的實現，就連方法的異常也能添加注解。下面演示幾個例子：?

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也有小的改動來識別新增的類型注解。?

?Optional??

?到目前為止，臭名昭著的空指針異常是導致Java應用程序失敗的最常見原因。以前，為了解決空指針異常，Google公司著名的Guava項目引入了Optional類，Guava通過使用檢查空值的方式來防止代碼污染，它鼓勵程序員寫更干凈的代碼。受到Google Guava的啟發，Optional類已經成為Java 8類庫的一部分。?

?Optional實際上是個容器：它可以保存類型T的值，或者僅僅保存null。Optional提供很多有用的方法，這樣我們就不用顯式進行空值檢測。更多詳情請參考官方文檔。?

?我們下面用兩個小例子來演示如何使用Optional類：一個允許為空值，一個不允許為空值。??

Optional< String > fullName = Optional.ofNullable( null );

System.out.println( "Full Name is set? " + fullName.isPresent() );? ? ? ??

System.out.println( "Full Name: " + fullName.orElseGet( () -> "[none]" ) );?

System.out.println( fullName.map( s -> "Hey " + s + "!" ).orElse( "Hey Stranger!" ) );

如果Optional類的實例為非空值的話，isPresent()返回true，否從返回false。為了防止Optional為空值，orElseGet()方法通過回調函數來產生一個默認值。map()函數對當前Optional的值進行轉化，然后返回一個新的Optional實例。orElse()方法和orElseGet()方法類似，但是orElse接受一個默認值而不是一個回調函數。下面是這個程序的輸出：?

Full Name is set? false

Full Name: [none]

Hey Stranger!

讓我們來看看另一個例子：

Optional< String > firstName = Optional.of( "Tom" );

System.out.println( "First Name is set? " + firstName.isPresent() );? ? ? ??

System.out.println( "First Name: " + firstName.orElseGet( () -> "[none]" ) );?

System.out.println( firstName.map( s -> "Hey " + s + "!" ).orElse( "Hey Stranger!" ) );

System.out.println();

下面是程序的輸出：?

First Name is set? true

First Name: Tom

Hey Tom!

更多詳情請參考官方文檔?

?方法引用??

?方法引用提供了非常有用的語法，可以直接引用已有Java類或對象（實例）的方法或構造器。與lambda聯合使用，方法引用可以使語言的構造更緊湊簡潔，減少冗余代碼。?

?下面，我們以定義了4個方法的Car這個類作為例子，區分Java中支持的4種不同的方法引用。??

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。請注意構造器沒有參數。?

final Car car = Car.create( Car::new );

final List< Car > cars = Arrays.asList( car );

第二種方法引用是靜態方法引用，它的語法是Class::static_method。請注意這個方法接受一個Car類型的參數。?

cars.forEach( Car::collide );

第三種方法引用是特定類的任意對象的方法引用，它的語法是Class::method。請注意，這個方法沒有參數。?

cars.forEach( Car::repair );

最后，第四種方法引用是特定對象的方法引用，它的語法是instance::method。請注意，這個方法接受一個Car類型的參數?

final Car police = Car.create( Car::new );

cars.forEach( police::follow );

運行上面的Java程序在控制臺上會有下面的輸出（Car的實例可能不一樣）：?

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

關于方法引用的更多詳情請參考官方文檔。?

?重復注解??

?自從Java 5引入了注解機制，這一特性就變得非常流行并且廣為使用。然而，使用注解的一個限制是相同的注解在同一位置只能聲明一次，不能聲明多次。Java 8打破了這條規則，引入了重復注解機制，這樣相同的注解可以在同一地方聲明多次。?

?重復注解機制本身必須用@Repeatable注解。事實上，這并不是語言層面上的改變，更多的是編譯器的技巧，底層的原理保持不變。讓我們看一個快速入門的例子：??

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的實例）。?

?程序輸出結果如下：??

filter1

filter2

更多詳情請參考官方文檔?

?JavaScript引擎Nashorn??

?Nashorn，一個新的JavaScript引擎隨著Java 8一起公諸于世，它允許在JVM上開發運行某些JavaScript應用。Nashorn就是javax.script.ScriptEngine的另一種實現，并且它們倆遵循相同的規則，允許Java與JavaScript相互調用。下面看一個例子：??

ScriptEngineManager manager = new ScriptEngineManager();

ScriptEngine engine = manager.getEngineByName( "JavaScript" );

? ? ? ? ?

System.out.println( engine.getClass().getName() );

System.out.println( "Result:" + engine.eval( "function f() { return 1; }; f() + 1;" ) );?

?下面是程序在控制臺上的輸出：?

jdk.nashorn.api.scripting.NashornScriptEngine

Result: 2?

?Base64??

在Java 8中，Base64編碼已經成為Java類庫的標準。它的使用十分簡單，下面讓我們看一個例子：?

package com.javacodegeeks.java8.base64;

import java.nio.charset.StandardCharsets;

import java.util.Base64;

public class Base64s {

? ? public static void main(String[] args) {

? ? ? ? final String text = "Base64 finally in Java 8!";

? ? ? ? ?

? ? ? ? final String encoded = Base64

? ? ? ? ? ? .getEncoder()

? ? ? ? ? ? .encodeToString( text.getBytes( StandardCharsets.UTF_8 ) );

? ? ? ? System.out.println( encoded );

? ? ? ? ?

? ? ? ? final String decoded = new String(?

? ? ? ? ? ? Base64.getDecoder().decode( encoded ),

? ? ? ? ? ? StandardCharsets.UTF_8 );

? ? ? ? System.out.println( decoded );

? ? }

}

程序在控制臺上輸出了編碼后的字符與解碼后的字符：

QmFzZTY0IGZpbmFsbHkgaW4gSmF2YSA4IQ==

Base64 finally in Java 8!?

Base64類同時還提供了對URL、MIME友好的編碼器與解碼器（Base64.getUrlEncoder() / Base64.getUrlDecoder(), Base64.getMimeEncoder() / Base64.getMimeDecoder()）。?

?結束語：??

本文寫于java9發布之后的幾天內，之所以想寫這篇文章是因為自己確實還沒有掌握清楚java 8的這些新特性，在編程語言呈現爆發的時段，java的份額越來越被擠壓的當今，java 8的發布我認為這意味著這是java的一個轉折點，意味著java語言再像其他語言學習，借鑒，這是java語言剛開始的那些年很像。不學習就要被淘汰，人如此，語言亦如此。

更多更全的java 8新特性請訪問?

Java 8新特性終極指南