歡迎光臨
每天分享高質量文章

【譯】Java 8的新特性—終極版

宣告:本文翻譯自Java 8 Features Tutorial – The ULTIMATE Guide,翻譯過程中發現併發編程網已經有同學翻譯過了:Java 8 特性 – 終極手冊,我還是堅持自己翻譯了一版(寫作驅動學習,加深印象),有些地方參考了該同學的。


前言: Java 8 已經發佈很久了,很多報道表明Java 8 是一次重大的版本升級。在Java Code Geeks上已經有很多介紹Java 8新特性的文章,例如Playing with Java 8 – Lambdas and Concurrency、Java 8 Date Time API Tutorial : LocalDateTime和Abstract Class Versus Interface in the JDK 8 Era。本文還參考了一些其他資料,例如:15 Must Read Java 8 Tutorials和The Dark Side of Java 8。本文綜合了上述資料,整理成一份關於Java 8新特性的參考教材,希望你有所收穫。

1. 簡介

毫無疑問,Java 8是Java自Java 5(發佈於2004年)之後的最重要的版本。這個版本包含語言、編譯器、庫、工具和JVM等方面的十多個新特性。在本文中我們將學習這些新特性,並用實際的例子說明在什麼場景下適合使用。

這個教程包含Java開發者經常面對的幾類問題:

  • 語言

  • 編譯器

  • 工具

  • 運行時(JVM)

2. Java語言的新特性

Java 8是Java的一個重大版本,有人認為,雖然這些新特性領Java開發人員十分期待,但同時也需要花不少精力去學習。在這一小節中,我們將介紹Java 8的大部分新特性。

2.1 Lambda運算式和函式式接口

Lambda運算式(也稱為閉包)是Java 8中最大和最令人期待的語言改變。它允許我們將函式當成引數傳遞給某個方法,或者把代碼本身當作資料處理:函式式開發者非常熟悉這些概念。很多JVM平臺上的語言(Groovy、Scala等)從誕生之日就支持Lambda運算式,但是Java開發者沒有選擇,只能使用匿名內部類代替Lambda運算式。

Lambda的設計耗費了很多時間和很大的社區力量,最終找到一種折中的實現方案,可以實現簡潔而緊湊的語言結構。最簡單的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. Arrays.asList( "a", "b", "d" ).forEach( e -> {

  2.    System.out.print( e );

  3.    System.out.print( e );

  4. } );

Lambda運算式可以取用類成員和區域性變數(會將這些變數隱式得轉換成final的),例如下列兩個代碼塊的效果完全相同:

  1. String separator = ",";

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

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

  1. final String separator = ",";

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

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

Lambda運算式有傳回值,傳回值的型別也由編譯器推理得出。如果Lambda運算式中的陳述句塊只有一行,則可以不用使用return陳述句,下列兩個代碼片段效果相同:

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

  1. Arrays.asList( "a", "b", "d" ).sort( ( e1, e2 ) -> {

  2.    int result = e1.compareTo( e2 );

  3.    return result;

  4. } );

Lambda的設計者們為了讓現有的功能與Lambda運算式良好兼容,考慮了很多方法,於是產生了函式接口這個概念。函式接口指的是只有一個函式的接口,這樣的接口可以隱式轉換為Lambda運算式。java.lang.Runnablejava.util.concurrent.Callable是函式式接口的最佳例子。在實踐中,函式式接口非常脆弱:只要某個開發者在該接口中添加一個函式,則該接口就不再是函式式接口進而導致編譯失敗。為了剋服這種代碼層面的脆弱性,並顯式說明某個接口是函式式接口,Java 8 提供了一個特殊的註解@FunctionalInterface(Java 庫中的所有相關接口都已經帶有這個註解了),舉個簡單的函式式接口的定義:

  1. @FunctionalInterface

  2. public interface Functional {

  3.    void method();

  4. }

不過有一點需要註意,預設方法和靜態方法不會破壞函式式接口的定義,因此如下的代碼是合法的。

  1. @FunctionalInterface

  2. public interface FunctionalDefaultMethods {

  3.    void method();

  4.    default void defaultMethod() {            

  5.    }        

  6. }

Lambda運算式作為Java 8的最大賣點,它有潛力吸引更多的開發者加入到JVM平臺,併在純Java編程中使用函式式編程的概念。如果你需要瞭解更多Lambda運算式的細節,可以參考官方文件。

2.2 接口的預設方法和靜態方法

Java 8使用兩個新概念擴展了接口的含義:預設方法和靜態方法。預設方法使得接口有點類似traits,不過要實現的標的不一樣。預設方法使得開發者可以在 不破壞二進制兼容性的前提下,往現存接口中添加新的方法,即不強制那些實現了該接口的類也同時實現這個新加的方法。

預設方法和抽象方法之間的區別在於抽象方法需要實現,而預設方法不需要。接口提供的預設方法會被接口的實現類繼承或者覆寫,例子代碼如下:

  1. private interface Defaulable {

  2.    // Interfaces now allow default methods, the implementer may or

  3.    // may not implement (override) them.

  4.    default String notRequired() {

  5.        return "Default implementation";

  6.    }        

  7. }

  8. private static class DefaultableImpl implements Defaulable {

  9. }

  10. private static class OverridableImpl implements Defaulable {

  11.    @Override

  12.    public String notRequired() {

  13.        return "Overridden implementation";

  14.    }

  15. }

Defaulable接口使用關鍵字default定義了一個預設方法notRequired()DefaultableImpl類實現了這個接口,同時預設繼承了這個接口中的預設方法;OverridableImpl類也實現了這個接口,但覆寫了該接口的預設方法,並提供了一個不同的實現。

Java 8帶來的另一個有趣的特性是在接口中可以定義靜態方法,例子代碼如下:

  1. private interface DefaulableFactory {

  2.    // Interfaces now allow static methods

  3.    static Defaulable create( Supplier< Defaulable > supplier ) {

  4.        return supplier.get();

  5.    }

  6. }

下麵的代碼片段整合了預設方法和靜態方法的使用場景:

  1. public static void main( String[] args ) {

  2.    Defaulable defaulable = DefaulableFactory.create( DefaultableImpl::new );

  3.    System.out.println( defaulable.notRequired() );

  4.    defaulable = DefaulableFactory.create( OverridableImpl::new );

  5.    System.out.println( defaulable.notRequired() );

  6. }

這段代碼的輸出結果如下:

  1. Default implementation

  2. Overridden implementation

由於JVM上的預設方法的實現在位元組碼層面提供了支持,因此效率非常高。預設方法允許在不打破現有繼承體系的基礎上改進接口。該特性在官方庫中的應用是:給java.util.Collection接口添加新方法,如stream()parallelStream()forEach()removeIf()等等。

儘管預設方法有這麼多好處,但在實際開發中應該謹慎使用:在複雜的繼承體系中,預設方法可能引起歧義和編譯錯誤。如果你想瞭解更多細節,可以參考官方文件。

2.3 方法取用

方法取用使得開發者可以直接取用現存的方法、Java類的構造方法或者實體物件。方法取用和Lambda運算式配合使用,使得java類的構造方法看起來緊湊而簡潔,沒有很多複雜的模板代碼。

西門的例子中,Car類是不同方法取用的例子,可以幫助讀者區分四種型別的方法取用。

  1. public static class Car {

  2.    public static Car create( final Supplier< Car > supplier ) {

  3.        return supplier.get();

  4.    }              

  5.    public static void collide( final Car car ) {

  6.        System.out.println( "Collided " + car.toString() );

  7.    }

  8.    public void follow( final Car another ) {

  9.        System.out.println( "Following the " + another.toString() );

  10.    }

  11.    public void repair() {  

  12.        System.out.println( "Repaired " + this.toString() );

  13.    }

  14. }

第一種方法取用的型別是建構式取用,語法是Class::new,或者更一般的形式:Class::new。註意:這個建構式沒有引數。

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

  2. 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. final Car police = Car.create( Car::new );

  2. cars.forEach( police::follow );

運行上述例子,可以在控制台看到如下輸出(Car實體可能不同):

  1. Collided com.javacodegeeks.java8.method.references.MethodReferences$Car@7a81197d

  2. Repaired com.javacodegeeks.java8.method.references.MethodReferences$Car@7a81197d

  3. Following the com.javacodegeeks.java8.method.references.MethodReferences$Car@7a81197d

如果想瞭解和學習更詳細的內容,可以參考官方文件

2.4 重覆註解

自從Java 5中引入註解以來,這個特性開始變得非常流行,併在各個框架和專案中被廣泛使用。不過,註解有一個很大的限制是:在同一個地方不能多次使用同一個註解。Java 8打破了這個限制,引入了重覆註解的概念,允許在同一個地方多次使用同一個註解。

在Java 8中使用@Repeatable註解定義重覆註解,實際上,這並不是語言層面的改進,而是編譯器做的一個trick,底層的技術仍然相同。可以利用下麵的代碼說明:

  1. package com.javacodegeeks.java8.repeatable.annotations;

  2. import java.lang.annotation.ElementType;

  3. import java.lang.annotation.Repeatable;

  4. import java.lang.annotation.Retention;

  5. import java.lang.annotation.RetentionPolicy;

  6. import java.lang.annotation.Target;

  7. public class RepeatingAnnotations {

  8.    @Target( ElementType.TYPE )

  9.    @Retention( RetentionPolicy.RUNTIME )

  10.    public @interface Filters {

  11.        Filter[] value();

  12.    }

  13.    @Target( ElementType.TYPE )

  14.    @Retention( RetentionPolicy.RUNTIME )

  15.    @Repeatable( Filters.class )

  16.    public @interface Filter {

  17.        String value();

  18.    };

  19.    @Filter( "filter1" )

  20.    @Filter( "filter2" )

  21.    public interface Filterable {        

  22.    }

  23.    public static void main(String[] args) {

  24.        for( Filter filter: Filterable.class.getAnnotationsByType( Filter.class ) ) {

  25.            System.out.println( filter.value() );

  26.        }

  27.    }

  28. }

正如我們所見,這裡的Filter類使用@Repeatable(Filters.class)註解修飾,而Filters是存放Filter註解的容器,編譯器儘量對開發者屏蔽這些細節。這樣,Filterable接口可以用兩個Filter註解註釋(這裡並沒有提到任何關於Filters的信息)。

另外,反射API提供了一個新的方法:getAnnotationsByType(),可以傳回某個型別的重覆註解,例如 Filterable.class.getAnnoation(Filters.class)將傳回兩個Filter實體,輸出到控制台的內容如下所示:

  1. filter1

  2. filter2

如果你希望瞭解更多內容,可以參考官方文件。

2.5 更好的型別推斷

Java 8編譯器在型別推斷方面有很大的提升,在很多場景下編譯器可以推匯出某個引數的資料型別,從而使得代碼更為簡潔。例子代碼如下:

  1. package com.javacodegeeks.java8.type.inference;

  2. public class Value< T > {

  3.    public static< T > T defaultValue() {

  4.        return null;

  5.    }

  6.    public T getOrDefault( T value, T defaultValue ) {

  7.        return ( value != null ) ? value : defaultValue;

  8.    }

  9. }

下列代碼是Value型別的應用:

  1. package com.javacodegeeks.java8.type.inference;

  2. public class TypeInference {

  3.    public static void main(String[] args) {

  4.        final Value< String > value = new Value<>();

  5.        value.getOrDefault( "22", Value.defaultValue() );

  6.    }

  7. }

引數Value.defaultValue()的型別由編譯器推導得出,不需要顯式指明。在Java 7中這段代碼會有編譯錯誤,除非使用 Value.<String>defaultValue()

2.6 拓寬註解的應用場景

Java 8拓寬了註解的應用場景。現在,註解幾乎可以使用在任何元素上:區域性變數、接口型別、超類和接口實現類,甚至可以用在函式的異常定義上。下麵是一些例子:

  1. package com.javacodegeeks.java8.annotations;

  2. import java.lang.annotation.ElementType;

  3. import java.lang.annotation.Retention;

  4. import java.lang.annotation.RetentionPolicy;

  5. import java.lang.annotation.Target;

  6. import java.util.ArrayList;

  7. import java.util.Collection;

  8. public class Annotations {

  9.    @Retention( RetentionPolicy.RUNTIME )

  10.    @Target( { ElementType.TYPE_USE, ElementType.TYPE_PARAMETER } )

  11.    public @interface NonEmpty {        

  12.    }

  13.    public static class Holder< @NonEmpty T > extends @NonEmpty Object {

  14.        public void method() throws @NonEmpty Exception {            

  15.        }

  16.    }

  17.    @SuppressWarnings( "unused" )

  18.    public static void main(String[] args) {

  19.        final Holder< String > holder = new @NonEmpty Holder< String >();        

  20.        @NonEmpty Collection< @NonEmpty String > strings = new ArrayList<>();        

  21.    }

  22. }

ElementType.TYPEUSERElementType.TYPEPARAMETER是Java 8新增的兩個註解,用於描述註解的使用場景。Java 語言也做了對應的改變,以識別這些新增的註解。

3. Java編譯器的新特性

3.1 引數名稱

為了在運行時獲得Java程式中方法的引數名稱,老一輩的Java程式員必須使用不同方法,例如Paranamer liberary。Java 8終於將這個特性規範化,在語言層面(使用反射API和Parameter.getName()方法)和位元組碼層面(使用新的javac編譯器以及-parameters引數)提供支持。

  1. package com.javacodegeeks.java8.parameter.names;

  2. import java.lang.reflect.Method;

  3. import java.lang.reflect.Parameter;

  4. public class ParameterNames {

  5.    public static void main(String[] args) throws Exception {

  6.        Method method = ParameterNames.class.getMethod( "main", String[].class );

  7.        for( final Parameter parameter: method.getParameters() ) {

  8.            System.out.println( "Parameter: " + parameter.getName() );

  9.        }

  10.    }

  11. }

在Java 8中這個特性是預設關閉的,因此如果不帶-parameters引數編譯上述代碼並運行,則會輸出如下結果:

  1. Parameter: arg0

如果帶-parameters引數,則會輸出如下結果(正確的結果):

  1. Parameter: args

如果你使用Maven進行專案管理,則可以在maven-compiler-plugin編譯器的配置項中配置-parameters引數:

  1.    org.apache.maven.plugins

  •    maven-compiler-plugin

  •    3.1

  •    

  •        -parameters

  •        1.8

  •        1.8

  •    

  • 4. Java官方庫的新特性

    Java 8增加了很多新的工具類(date/time類),並擴展了現存的工具類,以支持現代的併發編程、函式式編程等。

    4.1 Optional

    Java應用中最常見的bug就是空值異常。在Java 8之前,Google Guava引入了Optionals類來解決NullPointerException,從而避免原始碼被各種null檢查污染,以便開發者寫出更加整潔的代碼。Java 8也將Optional加入了官方庫。

    Optional僅僅是一個容易:存放T型別的值或者null。它提供了一些有用的接口來避免顯式的null檢查,可以參考Java 8官方文件瞭解更多細節。

    接下來看一點使用Optional的例子:可能為空的值或者某個型別的值:

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

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

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

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

    如果Optional實體持有一個非空值,則isPresent()方法傳回true,否則傳回false;orElseGet()方法,Optional實體持有null,則可以接受一個lambda運算式生成的預設值;map()方法可以將現有的Opetional實體的值轉換成新的值;orElse()方法與orElseGet()方法類似,但是在持有null的時候傳回傳入的預設值。

    上述代碼的輸出結果如下:

    1. Full Name is set? false

    2. Full Name: [none]

    3. Hey Stranger!

    再看下另一個簡單的例子:

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

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

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

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

    5. System.out.println();

    這個例子的輸出是:

    1. First Name is set? true

    2. First Name: Tom

    3. Hey Tom!

    如果想瞭解更多的細節,請參考官方文件。

    4.2 Streams

    新增的Stream API(java.util.stream)將生成環境的函式式編程引入了Java庫中。這是目前為止最大的一次對Java庫的完善,以便開發者能夠寫出更加有效、更加簡潔和緊湊的代碼。

    Stream API極大得簡化了集合操作(後面我們會看到不止是集合),首先看下這個叫Task的類:

    1. public class Streams  {

    2.    private enum Status {

    3.        OPEN, CLOSED

    4.    };

    5.    private static final class Task {

    6.        private final Status status;

    7.        private final Integer points;

    8.        Task( final Status status, final Integer points ) {

    9.            this.status = status;

    10.            this.points = points;

    11.        }

    12.        public Integer getPoints() {

    13.            return points;

    14.        }

    15.        public Status getStatus() {

    16.            return status;

    17.        }

    18.        @Override

    19.        public String toString() {

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

    21.        }

    22.    }

    23. }

    Task類有一個分數(或偽複雜度)的概念,另外還有兩種狀態:OPEN或者CLOSED。現在假設有一個task集合:

    1. final Collection< Task > tasks = Arrays.asList(

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

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

    4.    new Task( Status.CLOSED, 8 )

    5. );

    首先看一個問題:在這個task集合中一共有多少個OPEN狀態的點?在Java 8之前,要解決這個問題,則需要使用foreach迴圈遍歷task集合;但是在Java 8中可以利用steams解決:包括一系列元素的串列,並且支持順序和並行處理。

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

    2. final long totalPointsOfOpenTasks = tasks

    3.    .stream()

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

    5.    .mapToInt( Task::getPoints )

    6.    .sum();

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

    運行這個方法的控制台輸出是:

    1. Total points: 18

    這裡有很多知識點值得說。首先,tasks集合被轉換成steam表示;其次,在steam上的filter操作會過濾掉所有CLOSED的task;第三,mapToInt操作基於每個task實體的Task::getPoints方法將task流轉換成Integer集合;最後,通過sum方法計算總和,得出最後的結果。

    在學習下一個例子之前,還需要記住一些steams(點此更多細節)的知識點。Steam之上的操作可分為中間操作和晚期操作。

    中間操作會傳回一個新的steam——執行一個中間操作(例如filter)並不會執行實際的過濾操作,而是創建一個新的steam,並將原steam中符合條件的元素放入新創建的steam。

    晚期操作(例如forEach或者sum),會遍歷steam並得出結果或者附帶結果;在執行晚期操作之後,steam處理線已經處理完畢,就不能使用了。在幾乎所有情況下,晚期操作都是立刻對steam進行遍歷。

    steam的另一個價值是創造性地支持並行處理(parallel processing)。對於上述的tasks集合,我們可以用下麵的代碼計算所有任務的點數之和:

    1. // Calculate total points of all tasks

    2. final double totalPoints = tasks

    3.   .stream()

    4.   .parallel()

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

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

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

    這裡我們使用parallel方法並行處理所有的task,並使用reduce方法計算最終的結果。控制台輸出如下:

    1. Total pointsall tasks): 26.0

    對於一個集合,經常需要根據某些條件對其中的元素分組。利用steam提供的API可以很快完成這類任務,代碼如下:

    1. // Group tasks by their status

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

    3.    .stream()

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

    5. System.out.println( map );

    控制台的輸出如下:

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

    最後一個關於tasks集合的例子問題是:如何計算集合中每個任務的點數在集合中所占的比重,具體處理的代碼如下:

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

    2. final Collection< String > result = tasks

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

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

    5.    .asLongStream()                                  // LongStream

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

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

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

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

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

    11. System.out.println( result );

    控制台輸出結果如下:

    1. [19%, 50%, 30%]

    最後,正如之前所說,Steam API不僅可以作用於Java集合,傳統的IO操作(從檔案或者網絡一行一行得讀取資料)可以受益於steam處理,這裡有一個小例子:

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

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

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

    4. }

    Stream的方法onClose 傳回一個等價的有額外句柄的Stream,當Stream的close()方法被呼叫的時候這個句柄會被執行。Stream API、Lambda運算式還有接口預設方法和靜態方法支持的方法取用,是Java 8對軟體開發的現代範式的響應。

    4.3 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中新的時間和日期管理API深受Joda-Time影響,並吸收了很多Joda-Time的精華。新的java.time包包含了所有關於日期、時間、時區、Instant(跟日期類似但是精確到納秒)、duration(持續時間)和時鐘操作的類。新設計的API認真考慮了這些類的不變性(從java.util.Calendar吸取的教訓),如果某個實體需要修改,則傳回一個新的物件。

    我們接下來看看java.time包中的關鍵類和各自的使用例子。首先,Clock類使用時區來傳回當前的納秒時間和日期。Clock可以替代System.currentTimeMillis()TimeZone.getDefault()

    1. // Get the system clock as UTC offset

    2. final Clock clock = Clock.systemUTC();

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

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

    這個例子的輸出結果是:

    1. 2014-04-12T15:19:29.282Z

    2. 1397315969360

    第二,關註下LocalDateLocalTime類。LocalDate僅僅包含ISO-8601日曆系統中的日期部分;LocalTime則僅僅包含該日曆系統中的時間部分。這兩個類的物件都可以使用Clock物件構建得到。

    1. // Get the local date and local time

    2. final LocalDate date = LocalDate.now();

    3. final LocalDate dateFromClock = LocalDate.now( clock );

    4. System.out.println( date );

    5. System.out.println( dateFromClock );

    6. // Get the local date and local time

    7. final LocalTime time = LocalTime.now();

    8. final LocalTime timeFromClock = LocalTime.now( clock );

    9. System.out.println( time );

    10. System.out.println( timeFromClock );

    上述例子的輸出結果如下:

    1. 2014-04-12

    2. 2014-04-12

    3. 11:25:54.568

    4. 15:25:54.568

    LocalDateTime類包含了LocalDate和LocalTime的信息,但是不包含ISO-8601日曆系統中的時區信息。這裡有一些關於LocalDate和LocalTime的例子:

    1. // Get the local date/time

    2. final LocalDateTime datetime = LocalDateTime.now();

    3. final LocalDateTime datetimeFromClock = LocalDateTime.now( clock );

    4. System.out.println( datetime );

    5. System.out.println( datetimeFromClock );

    上述這個例子的輸出結果如下:

    1. 2014-04-12T11:37:52.309

    2. 2014-04-12T15:37:52.309

    如果你需要特定時區的data/time信息,則可以使用ZoneDateTime,它儲存有ISO-8601日期系統的日期和時間,而且有時區信息。下麵是一些使用不同時區的例子:

    1. // Get the zoned date/time

    2. final ZonedDateTime zonedDatetime = ZonedDateTime.now();

    3. final ZonedDateTime zonedDatetimeFromClock = ZonedDateTime.now( clock );

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

    5. System.out.println( zonedDatetime );

    6. System.out.println( zonedDatetimeFromClock );

    7. System.out.println( zonedDatetimeFromZone );

    這個例子的輸出結果是:

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

    2. 2014-04-12T15:47:01.017Z

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

    最後看下Duration類,它持有的時間精確到秒和納秒。這使得我們可以很容易得計算兩個日期之間的不同,例子代碼如下:

    1. // Get duration between two dates

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

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

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

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

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

    這個例子用於計算2014年4月16日和2015年4月16日之間的天數和小時數,輸出結果如下:

    1. Duration in days: 365

    2. Duration in hours: 8783

    對於Java 8的新日期時間的總體印象還是比較積極的,一部分是因為Joda-Time的積極影響,另一部分是因為官方終於聽取了開發人員的需求。如果希望瞭解更多細節,可以參考官方文件。

    4.4 Nashorn JavaScript引擎

    Java 8提供了新的Nashorn JavaScript引擎,使得我們可以在JVM上開發和運行JS應用。Nashorn JavaScript引擎是javax.script.ScriptEngine的另一個實現版本,這類Script引擎遵循相同的規則,允許Java和JavaScript交互使用,例子代碼如下:

    1. ScriptEngineManager manager = new ScriptEngineManager();

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

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

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

    這個代碼的輸出結果如下:

    1. jdk.nashorn.api.scripting.NashornScriptEngine

    2. Result: 2

    4.5 Base64

    對Base64編碼的支持已經被加入到Java 8官方庫中,這樣不需要使用第三方庫就可以進行Base64編碼,例子代碼如下:

    1. package com.javacodegeeks.java8.base64;

    2. import java.nio.charset.StandardCharsets;

    3. import java.util.Base64;

    4. public class Base64s {

    5.    public static void main(String[] args) {

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

    7.        final String encoded = Base64

    8.            .getEncoder()

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

    10.        System.out.println( encoded );

    11.        final String decoded = new String(

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

    13.            StandardCharsets.UTF_8 );

    14.        System.out.println( decoded );

    15.    }

    16. }

    這個例子的輸出結果如下:

    1. QmFzZTY0IGZpbmFsbHkgaW4gSmF2YSA4IQ==

    2. Base64 finally in Java 8!

    新的Base64API也支持URL和MINE的編碼解碼。
    (Base64.getUrlEncoder() / Base64.getUrlDecoder()Base64.getMimeEncoder() / Base64.getMimeDecoder())。

    4.6 並行陣列

    Java8版本新增了很多新的方法,用於支持並行陣列處理。最重要的方法是parallelSort(),可以顯著加快多核機器上的陣列排序。下麵的例子論證了parallexXxx系列的方法:

    1. package com.javacodegeeks.java8.parallel.arrays;

    2. import java.util.Arrays;

    3. import java.util.concurrent.ThreadLocalRandom;

    4. public class ParallelArrays {

    5.    public static void main( String[] args ) {

    6.        long[] arrayOfLong = new long [ 20000 ];        

    7.        Arrays.parallelSetAll( arrayOfLong,

    8.            index -> ThreadLocalRandom.current().nextInt( 1000000 ) );

    9.        Arrays.stream( arrayOfLong ).limit( 10 ).forEach(

    10.            i -> System.out.print( i + " " ) );

    11.        System.out.println();

    12.        Arrays.parallelSort( arrayOfLong );        

    13.        Arrays.stream( arrayOfLong ).limit( 10 ).forEach(

    14.            i -> System.out.print( i + " " ) );

    15.        System.out.println();

    16.    }

    17. }

    上述這些代碼使用parallelSetAll()方法生成20000個隨機數,然後使用parallelSort()方法進行排序。這個程式會輸出亂序陣列和排序陣列的前10個元素。上述例子的代碼輸出的結果是:

    1. Unsorted: 591217 891976 443951 424479 766825 351964 242997 642839 119108 552378

    2. Sorted: 39 220 263 268 325 607 655 678 723 793

    4.7 併發性

    基於新增的lambda運算式和steam特性,為Java 8中為java.util.concurrent.ConcurrentHashMap類添加了新的方法來支持聚焦操作;另外,也為java.util.concurrentForkJoinPool類添加了新的方法來支持通用執行緒池操作(更多內容可以參考我們的併發編程課程)。

    Java 8還添加了新的java.util.concurrent.locks.StampedLock類,用於支持基於容量的鎖——該鎖有三個模型用於支持讀寫操作(可以把這個鎖當做是java.util.concurrent.locks.ReadWriteLock的替代者)。

    java.util.concurrent.atomic包中也新增了不少工具類,列舉如下:

    • DoubleAccumulator

    • DoubleAdder

    • LongAccumulator

    • LongAdder

    5. 新的Java工具

    Java 8提供了一些新的命令列工具,這部分會講解一些對開發者最有用的工具。

    5.1 Nashorn引擎:jjs

    jjs是一個基於標準Nashorn引擎的命令列工具,可以接受js原始碼並執行。例如,我們寫一個func.js檔案,內容如下:

    1. function f() {

    2.     return 1;

    3. };

    4. print( f() + 1 );

    可以在命令列中執行這個命令: jjs func.js,控制台輸出結果是:

    1. 2

    如果需要瞭解細節,可以參考官方文件。

    5.2 類依賴分析器:jdeps

    jdeps是一個相當棒的命令列工具,它可以展示包層級和類層級的Java類依賴關係,它以.class檔案、目錄或者Jar檔案為輸入,然後會把依賴關係輸出到控制台。

    我們可以利用jedps分析下Spring Framework庫,為了讓結果少一點,僅僅分析一個JAR檔案:org.springframework.core-3.0.5.RELEASE.jar

    1. jdeps org.springframework.core-3.0.5.RELEASE.jar

    這個命令會輸出很多結果,我們僅看下其中的一部分:依賴關係按照包分組,如果在classpath上找不到依賴,則顯示"not found".

    1. org.springframework.core-3.0.5.RELEASE.jar -> C:\Program Files\Java\jdk1.8.0\jre\lib\rt.jar

    2.   org.springframework.core (org.springframework.core-3.0.5.RELEASE.jar)

    3.      -> java.io                                            

    4.      -> java.lang                                          

    5.      -> java.lang.annotation                              

    6.      -> java.lang.ref                                      

    7.      -> java.lang.reflect                                  

    8.      -> java.util                                          

    9.      -> java.util.concurrent                              

    10.      -> org.apache.commons.logging                         not found

    11.      -> org.springframework.asm                            not found

    12.      -> org.springframework.asm.commons                    not found

    13.   org.springframework.core.annotation (org.springframework.core-3.0.5.RELEASE.jar)

    14.      -> java.lang                                          

    15.      -> java.lang.annotation                              

    16.      -> java.lang.reflect                                  

    17.      -> java.util

    更多的細節可以參考官方文件。

    6. JVM的新特性

    使用Metaspace(JEP 122)代替持久代(PermGen space)。在JVM引數方面,使用-XX:MetaSpaceSize-XX:MaxMetaspaceSize代替原來的-XX:PermSize-XX:MaxPermSize

    7. 結論

    通過為開發者提供很多能夠提高生產力的特性,Java 8使得Java平臺前進了一大步。現在還不太適合將Java 8應用在生產系統中,但是在之後的幾個月中Java 8的應用率一定會逐步提高(PS:原文時間是2014年5月9日,現在在很多公司Java 8已經成為主流,我司由於體量太大,現在也在一點點上Java 8,雖然慢但是好歹在升級了)。作為開發者,現在應該學習一些Java 8的知識,為升級做好準備。

    關於Spring:對於企業級開發,我們也應該關註Spring社區對Java 8的支持,可以參考這篇文章——Spring 4支持的Java 8新特性一覽

    8. 參考資料

    • What’s New in JDK 8

    • The Java Tutorials

    • WildFly 8, JDK 8, NetBeans 8, Java EE

    • Java 8 Tutorial

    • JDK 8 Command-line Static Dependency Checker

    • The Illuminating Javadoc of JDK

    • The Dark Side of Java 8

    • Installing Java™ 8 Support in Eclipse Kepler SR2

    • Java 8

    • Oracle Nashorn. A Next-Generation JavaScript Engine for the JVM



    推薦一個我最近在學的JVM課程,來自Oracle高級研究員鄭宇迪在極客時間的JVM專欄,目前更新了12篇文章,我基本都跟下來了,質量值得信賴。


    整個專欄將分為四大模塊。

    1. 基本原理:剖析 Java 虛擬機的運行機制,逐一介紹 Java 虛擬機的設計決策以及工程實現;

    2. 高效實現:探索 Java 編譯器,以及內嵌於 Java 虛擬機中的即時編譯器,幫助你更好地理解 Java 語言特性,繼而寫出簡潔高效的代碼;

    3. 代碼優化:介紹如何利用工具定位並解決代碼中的問題,以及在已有工具不適用的情況下,如何打造專屬輪子;

    4. 虛擬機黑科技:介紹甲骨文實驗室近年來的前沿工作之一 GraalVM。包括如何在 JVM 上高效運行其他語言;如何混搭這些語言,實現 Polyglot;如何將這些語言事前編譯(Ahead-Of-Time,AOT)成機器指令,單獨運行甚至嵌入至資料庫中運行。



    赞(0)

    分享創造快樂

    © 2021 知識星球   网站地图