[[384419]]

本文轉載自微信公眾號「Java極客技術」，作者 鴨血粉絲。轉載本文請聯系Java極客技術公眾號。

一、介紹

Java 8 已經發布很久了，很多報道表明 Java 8 是一次重大的版本升級，雖然我們的 JDK 環境也升級到1.8，但是在日常的開發過程中，使用最多的編程風格還是停留在 JDK1.7。

Java8 新增了非常多的特性，主要有以下幾個：

• Lambda 表達式：Lambda 允許把函數作為一個方法的參數(函數作為參數傳遞到方法中)
• 函數式接口：指的是一個有且僅有一個抽象方法，但是可以有多個非抽象方法的接口，這樣的接口可以隱式轉換為 Lambda 表達式
• 方法引用：方法引用提供了非常有用的語法，可以直接引用已有Java類或對象(實例)的方法或構造器。與lambda聯合使用，方法引用可以使語言的構造更緊湊簡潔，減少冗余代碼
• 默認方法：默認方法就是一個在接口里面有了一個實現的方法
• Stream API：新添加的Stream API(java.util.stream) 把真正的函數式編程風格引入到Java中。
• Optional 類：Optional 類已經成為 Java 8 類庫的一部分，用來解決空指針異常。
• Date Time API：加強對日期與時間的處理。
• Nashorn, JavaScript 引擎：Java 8提供了一個新的Nashorn javascript引擎，它允許我們在JVM上運行特定的javascript應用

有很多人認為，Java 8 的一些新特性另 Java 開發人員十分滿意，在本篇文章中，我們將詳細介紹 Java 8 的這些新特性!

話不多說，直接上代碼!

二、Lambda 表達式

Lambda 表達式，也稱為閉包，是 Java 8 中最大和最令人期待的語言改變。它允許我們將函數當成參數傳遞給某個方法，或者把代碼本身當作數據處理，函數式開發者非常熟悉這些概念。

很多JVM平臺上的語言(Groovy、Scala等)從誕生之日就支持 Lambda 表達式，但是 Java 開發者沒有選擇，只能使用匿名內部類代替Lambda表達式。

//匿名內部類方式排序 
List<String> names = Arrays.asList( "a", "b", "d" ); 
 
Collections.sort(names, new Comparator<String>() { 
    @Override 
    public int compare(String s1, String s2) { 
        return s1.compareTo(s2); 
    } 
}); 

Lambda 的設計可謂耗費了很多時間和很大的社區力量，最終找到一種折中的實現方案，可以實現簡潔而緊湊的語言結構。

Lambda 表達式的語法格式：

(parameters) -> expression 
或 
(parameters) ->{ statements; } 

Lambda 編程風格，可以總結為四類：

• 可選類型聲明：不需要聲明參數類型，編譯器可以統一識別參數值
• 可選的參數圓括號：一個參數無需定義圓括號，但多個參數需要定義圓括號
• 可選的大括號：如果主體包含了一個語句，就不需要使用大括號
• 可選的返回關鍵字：如果主體只有一個表達式返回值則編譯器會自動返回值，大括號需要指定明表達式返回了一個數值

2.1、可選類型聲明

在使用過程中，我們可以不用顯示聲明參數類型，編譯器可以統一識別參數類型，例如：

Collections.sort(names, (s1, s2) -> s1.compareTo(s2)); 

上面代碼中的參數s1、s2的類型是由編譯器推理得出的，你也可以顯式指定該參數的類型，例如：

Collections.sort(names, (String s1, String s2) -> s1.compareTo(s2)); 

運行之后，兩者結果一致!

2.2、可選的參數圓括號

當方法那只有一個參數時，無需定義圓括號，例如：

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

但多個參數時，需要定義圓括號，例如：

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

2.3、可選的大括號

當主體只包含了一行時，無需使用大括號，例如：

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

當主體包含多行時，需要使用大括號，例如：

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

2.4、可選的返回關鍵字

如果表達式中的語句塊只有一行，則可以不用使用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; 
} ); 

2.5、變量作用域

還有一點需要了解的是，Lambda 表達式可以引用類成員和局部變量，但是會將這些變量隱式得轉換成final，例如：

String separator = ","; 
Arrays.asList( "a", "b", "c" ).forEach( 
    ( String e ) -> System.out.print( e + separator ) ); 

和

final String separator = ","; 
Arrays.asList( "a", "b", "c" ).forEach( 
    ( String e ) -> System.out.print( e + separator ) ); 

兩者等價!

同時，Lambda 表達式的局部變量可以不用聲明為final，但是必須不可被后面的代碼修改(即隱性的具有 final 的語義)，例如：

int num = 1; 
Arrays.asList(1,2,3,4).forEach(e -> System.out.println(num + e)); 
num =2; 
//報錯信息：Local variable num defined in an enclosing scope must be final or effectively final 

在 Lambda 表達式當中不允許聲明一個與局部變量同名的參數或者局部變量，例如：

int num = 1; 
Arrays.asList(1,2,3,4).forEach(num -> System.out.println(num)); 
//報錯信息：Variable 'num' is already defined in the scope 

三、函數式接口

Lambda 的設計者們為了讓現有的功能與 Lambda 表達式良好兼容，考慮了很多方法，于是產生了函數接口這個概念。

函數接口指的是一個有且僅有一個抽象方法，但是可以有多個非抽象方法的接口，這樣的接口可以隱式轉換為 Lambda 表達式。

但是在實踐中，函數式接口非常脆弱，只要某個開發者在該接口中添加一個函數，則該接口就不再是函數式接口進而導致編譯失敗。為了克服這種代碼層面的脆弱性，并顯式說明某個接口是函數式接口，Java 8 提供了一個特殊的注解@FunctionalInterface，舉個簡單的函數式接口的定義：

@FunctionalInterface 
public interface GreetingService { 
 
    void sayMessage(String message); 
} 

Java7 只能通過匿名內部類進行編程，例如：

GreetingService greetService = new GreetingService() { 
 
    @Override 
    public void sayMessage(String message) { 
        System.out.println("Hello " + message); 
    } 
}; 
greetService.sayMessage("world"); 

Java8 可以采用 Lambda 表達方進行編程，例如：

GreetingService greetService = message -> System.out.println("Hello " + message); 
greetService.sayMessage("world"); 

目前 Java 庫中的所有相關接口都已經帶有這個注解了，實踐上java.lang.Runnable和java.util.concurrent.Callable是函數式接口的最佳例子!

四、方法引用

方法引用使用一對冒號::，通過方法的名字來指向一個方法。

方法引用可以使語言的構造更緊湊簡潔，減少冗余代碼。

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

public class Car { 
 
    //Supplier是jdk1.8的接口，這里和lamda一起使用了 
    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()); 
    } 
} 

4.1、構造器引用

它的語法是Class::new，或者更一般的Class< T >::new，實例如下：

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

4.2、靜態方法引用

它的語法是Class::static_method，實例如下：

cars.forEach( Car::collide ); 

4.3、類的成員方法引用

它的語法是Class::method，實例如下：

cars.forEach( Car::repair ); 

4.4、實例對象的成員方法的引用

它的語法是instance::method，實例如下

final Car police = Car.create( Car::new ); 
cars.forEach( police::follow ); 

注意：這個方法接受一個Car類型的參數!

運行上述例子，可以在控制臺看到如下輸出：

Collided com.example.jdk8.methodrefer.Car@15aeb7ab 
Repaired com.example.jdk8.methodrefer.Car@15aeb7ab 
Following the com.example.jdk8.methodrefer.Car@15aeb7ab 

五、默認方法

Java 8使用兩個新概念擴展了接口的含義：默認方法和靜態方法。

默認方法使得開發者可以在不破壞二進制兼容性的前提下，往現存接口中添加新的方法，即不強制那些實現了該接口的類也同時實現這個新加的方法。

為什么要有這個特性?首先，之前的接口是個雙刃劍，好處是面向抽象而不是面向具體編程，缺陷是，當需要修改接口時候，需要修改全部實現該接口的類，目前的 java 8 之前的集合框架沒有 foreach 方法，通常能想到的解決辦法是在JDK里給相關的接口添加新的方法及實現。然而，對于已經發布的版本，是沒法在給接口添加新方法的同時不影響已有的實現。所以引進的默認方法。他們的目的是為了解決接口的修改與現有的實現不兼容的問題。

默認方法、靜態方法語法格式如下：

public interface Vehicle { 
 
 //默認方法 
   default void print(){ 
      System.out.println("我是一輛車!"); 
   } 
    // 靜態方法 
   static void blowHorn(){ 
      System.out.println("按喇叭!!!"); 
   } 
} 

我們可以通過以下代碼來了解關于默認方法的使用，實例如下：

public class Tester { 
   public static void main(String args[]){ 
      Vehicle vehicle = new Car(); 
      vehicle.print(); 
   } 
} 
  
interface Vehicle { 
   default void print(){ 
      System.out.println("我是一輛車!"); 
   } 
     
   static void blowHorn(){ 
      System.out.println("按喇叭!!!"); 
   } 
} 
  
interface FourWheeler { 
   default void print(){ 
      System.out.println("我是一輛四輪車!"); 
   } 
} 
  
class Car implements Vehicle, FourWheeler { 
   public void print(){ 
      Vehicle.super.print(); 
      FourWheeler.super.print(); 
      Vehicle.blowHorn(); 
      System.out.println("我是一輛汽車!"); 
   } 
} 

執行以上腳本，輸出結果為：

我是一輛車!

我是一輛四輪車!

按喇叭!!!

我是一輛汽車!

六、Stream

Java 8 API添加了一個新的java.util.stream工具包，被稱為流 Stream，可以讓你以一種聲明的方式處理數據，這是目前為止最大的一次對 Java 庫的完善。

Stream 使用一種類似用 SQL 語句從數據庫查詢數據的直觀方式來提供一種對 Java 集合運算和表達的高階抽象。

Stream API 可以極大提高 Java 程序員的生產力，讓程序員寫出高效率、干凈、簡潔的代碼。

這種風格將要處理的元素集合看作一種流， 流在管道中傳輸， 并且可以在管道的節點上進行處理， 比如篩選， 排序，聚合等。

元素流在管道中經過中間操作(intermediate operation)的處理，最后由最終操作(terminal operation)得到前面處理的結果。

+--------------------+       +------+   +------+   +---+   +-------+ 
| stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect| 
+--------------------+       +------+   +------+   +---+   +-------+ 

以上的流程轉換為 Java 代碼，實例如下：

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5); 
// 獲取集合中大于2、并且經過排序、平方去重的有序集合 
List<Integer> squaresList = numbers 
        .stream() 
        .filter(x -> x > 2) 
        .sorted((x,y) -> x.compareTo(y)) 
        .map( i -> i*i).distinct().collect(Collectors.toList()); 

在 Java 8 中，集合接口有兩個方法來生成流：

• stream()：為集合創建串行流
• parallelStream()：為集合創建并行流

當然，流的來源可以是集合，數組，I/O channel， 產生器generator 等!

6.1、filter

filter方法用于通過設置的條件過濾出元素。以下代碼片段使用filter方法過濾出空字符串。

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl"); 
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList()); 

6.2、limit

limit方法用于獲取指定數量的流。以下代碼片段使用limit方法打印出 10 條數據：

Random random = new Random(); 
random.ints().limit(10).forEach(System.out::println); 

6.3、sorted

sorted方法用于對流進行排序。以下代碼片段使用sorted方法對集合中的數字進行排序：

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5); 
numbers.stream().sorted().forEach(System.out::println); 

6.4、map

map方法用于映射每個元素到對應的結果，以下代碼片段使用map輸出了元素對應的平方數：

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5); 
// 獲取對應的平方數 
List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList()); 

6.5、forEach

forEach方法用于迭代流中的每個數據。以下代碼片段使用forEach輸出集合中的數字：

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5); 
numbers.stream().forEach(System.out::println); 

6.6、Collectors

Collectors類實現了很多歸約操作，例如將流轉換成集合和聚合元素。Collectors可用于返回列表或字符串：

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl"); 
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList()); 
 
System.out.println("篩選列表: " + filtered); 
String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", ")); 
System.out.println("合并字符串: " + mergedString); 

6.7、統計

一些產生統計結果的收集器也非常有用。它們主要用于int、double、long等基本類型上，它們可以用來產生類似如下的統計結果：

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5); 
  
IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics(); 
  
System.out.println("列表中最大的數 : " + stats.getMax()); 
System.out.println("列表中最小的數 : " + stats.getMin()); 
System.out.println("所有數之和 : " + stats.getSum()); 
System.out.println("平均數 : " + stats.getAverage()); 

6.8、并行(parallel)程序

parallelStream是流并行處理程序的代替方法。以下實例我們使用 parallelStream來輸出空字符串的數量：

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl"); 
// 獲取空字符串的數量 
long count = strings.parallelStream().filter(string -> string.isEmpty()).count(); 

更多實例，可以參考這里官方 API 文檔!

七、Optional 類

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

Optional 提供了一些有用的方法來避免顯式的 null 檢查，我們可以通過以下實例來更好的了解 Optional 類的使用!

public class OptionalTester { 
 
    public static void main(String[] args) { 
        OptionalTester tester = new OptionalTester(); 
        Integer value1 = null; 
        Integer value2 = new Integer(10); 
 
        // Optional.ofNullable - 允許傳遞為 null 參數 
        Optional<Integer> a = Optional.ofNullable(value1); 
 
        // Optional.of - 如果傳遞的參數是 null，拋出異常 NullPointerException 
        Optional<Integer> b = Optional.of(value2); 
        System.out.println(tester.sum(a,b)); 
    } 
 
    public Integer sum(Optional<Integer> a, Optional<Integer> b){ 
 
        // Optional.isPresent - 判斷值是否存在 
 
        System.out.println("第一個參數值存在: " + a.isPresent()); 
        System.out.println("第二個參數值存在: " + b.isPresent()); 
 
        // Optional.orElse - 如果值存在，返回它，否則返回默認值 
        Integer value1 = a.orElse(new Integer(0)); 
 
        //Optional.get - 獲取值，值需要存在 
        Integer value2 = b.get(); 
        return value1 + value2; 
    } 
} 

如果想要了解更多用法，可以參考這篇文章：Optional 官方 API

八、新的日期時間 API

Java 8引入了新的 Date-Time API(JSR 310) 來改進時間、日期的處理!

在舊版的 Java 中，日期時間 API 存在諸多問題，例如：

• 非線程安全：java.util.Date 是非線程安全的，所有的日期類都是可變的，這是Java日期類最大的問題之一。
• 設計很差：Java的日期/時間類的定義并不一致，在java.util和java.sql的包中都有日期類，此外用于格式化和解析的類被定義在java.text包中。java.util.Date同時包含日期和時間，而java.sql.Date僅包含日期，將其納入java.sql包并不合理。另外這兩個類都有相同的名字，這本身就是一個非常糟糕的設計。
• 時區處理麻煩：日期類并不提供國際化，沒有時區支持，因此 Java 引入了java.util.Calendar和java.util.TimeZone類，但他們同樣存在上述所有的問題。

因為上面這些原因，誕生了第三方庫Joda-Time，可以替代 Java 的時間管理 API 。

Java 8 中新的時間和日期管理 API 深受Joda-Time影響，并吸收了很多Joda-Time的精華，新的java.time包包含了所有關于日期、時間、時區、Instant(跟日期類似但是精確到納秒)、duration(持續時間)和時鐘操作的類。

新設計的 API 認真考慮了這些類的不變性，如果某個實例需要修改，則返回一個新的對象。

接下來看看java.time包中的關鍵類和各自的使用例子。

8.1、Clock類

Clock類使用時區來返回當前的納秒時間和日期。Clock可以替代System.currentTimeMillis()和TimeZone.getDefault()，實例如下：

final Clock clock = Clock.systemUTC(); 
System.out.println( clock.instant() ); 
System.out.println( clock.millis() ); 

輸出結果是

2021-02-24T12:24:54.678Z 
1614169494678 

8.2、LocalDate、LocalTime 和 LocalDateTime類

LocalDate、LocalTime 和 LocalDateTime 類，都是用于處理日期時間的 API，在處理日期時間時可以不用強制性指定時區。

8.2.1、LocalDate

LocalDate 僅僅包含ISO-8601日歷系統中的日期部分，實例如下：

//獲取當前日期 
final LocalDate date = LocalDate.now(); 
//獲取指定時鐘的日期 
final LocalDate dateFromClock = LocalDate.now( clock ); 
 
System.out.println( date ); 
System.out.println( dateFromClock ); 

輸出結果：

2021-02-24 
2021-02-24 

8.2.2、LocalTime

LocalTime 僅僅包含該日歷系統中的時間部分，實例如下：

//獲取當前時間 
final LocalTime time = LocalTime.now(); 
//獲取指定時鐘的時間 
final LocalTime timeFromClock = LocalTime.now( clock ); 
 
System.out.println( time ); 
System.out.println( timeFromClock ); 

輸出結果：

20:36:16.315 
20:36:16.315 

8.2.3、LocalDateTime

LocalDateTime 類包含了 LocalDate 和 LocalTime 的信息，但是不包含 ISO-8601 日歷系統中的時區信息，實例如下：

//獲取當前日期時間 
final LocalDateTime datetime = LocalDateTime.now(); 
//獲取指定時鐘的日期時間 
final LocalDateTime datetimeFromClock = LocalDateTime.now( clock ); 
 
System.out.println( datetime ); 
System.out.println( datetimeFromClock ); 

輸出結果：

2021-02-24T20:38:13.633 
2021-02-24T20:38:13.633 

8.3、ZonedDateTime類

如果你需要特定時區的信息，則可以使用 ZoneDateTime，它保存有 ISO-8601 日期系統的日期和時間，而且有時區信息，實例如下：

// 獲取當前時間日期 
final ZonedDateTime zonedDatetime = ZonedDateTime.now(); 
//獲取指定時鐘的日期時間 
final ZonedDateTime zonedDatetimeFromClock = ZonedDateTime.now( clock ); 
//獲取紐約時區的當前時間日期 
final ZonedDateTime zonedDatetimeFromZone = ZonedDateTime.now( ZoneId.of("America/New_York") ); 
 
System.out.println( zonedDatetime ); 
System.out.println( zonedDatetimeFromClock ); 
System.out.println( zonedDatetimeFromZone ); 

輸出結果：

2021-02-24T20:42:27.238+08:00[Asia/Shanghai] 
2021-02-24T12:42:27.238Z 
2021-02-24T07:42:27.241-05:00[America/New_York] 

8.4、Duration類

Duration類，它持有的時間精確到秒和納秒。利用它我們可以很容易得計算兩個日期之間的不同，實例如下：

final LocalDateTime from = LocalDateTime.of( 2020, Month.APRIL, 16, 0, 0, 0 ); 
final LocalDateTime to = LocalDateTime.of( 2021, 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() ); 

輸出結果：

Duration in days: 365 
Duration in hours: 8783 

九、Base64

在 Java 7中，我們經常需要使用第三方庫就可以進行 Base64 編碼。

在 Java 8中，Base64 編碼已經成為 Java 類庫的標準，實例如下：

public class Tester { 
    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! 

新的 Base64API 也支持 URL 和 MINE 的編碼解碼，詳情可以查看具體類方法。

十、Nashorn JavaScript 引擎

從 JDK 1.8 開始，Nashorn 取代 Rhino(JDK 1.6, JDK1.7) 成為 Java 的嵌入式 JavaScript 引擎。它使用基于 JSR 292 的新語言特性，將 JavaScript 編譯成 Java 字節碼。

與先前的 Rhino 實現相比，這帶來了 2 到 10 倍的性能提升，實例如下：

public class JavaScriptTester { 
 
    public static void main(String[] args) { 
        ScriptEngineManager scriptEngineManager = new ScriptEngineManager(); 
        ScriptEngine nashorn = scriptEngineManager.getEngineByName("nashorn"); 
 
        String name = "Hello World"; 
        try { 
            nashorn.eval("print('" + name + "')"); 
        }catch(ScriptException e){ 
            System.out.println("執行腳本錯誤: "+ e.getMessage()); 
        } 
    } 
} 

輸出結果：

Hello World 

在實際的開發中，使用的比較少!

十一、總結

Java 8 使得 Java 平臺又前進了一大步，尤其是 Stream 流操作，使用的時候非常的爽，整個代碼看起來也更加的簡潔、直觀、舒服!

現在 JDK 已經更新到13了，在后期，小編也會陸續給大家介紹新特性，歡迎點贊吐槽!

十二、參考

1、菜鳥教程 - Java 8 新特性

 

2、簡書 - Java 8的新特性