Java8新特性

Java8新特性

Java8主要的新特性涵蓋：函數式接口、Lambda 表達式、集合的流式操做、註解的更新、安全性的加強、IO\NIO 的改進、完善的全球化功能等。

一、函數式接口

    Java 8 引入的一個核心概念是函數式接口（Functional Interfaces）。經過在接口裏面添加一個抽象方法，這些方法能夠直接從接口中運行。若是一個接口定義個惟一一個抽象方法，那麼這個接口就成爲函數式接口。同時，引入了一個新的註解：@FunctionalInterface。能夠把他它放在一個接口前，表示這個接口是一個函數式接口。這個註解是非必須的，只要接口只包含一個方法的接口，虛擬機會自動判斷，不過最好在接口上使用註解 @FunctionalInterface 進行聲明。在接口中添加了 @FunctionalInterface 的接口，只容許有一個抽象方法，不然編譯器也會報錯。

java.lang.Runnable 就是一個函數式接口。

@FunctionalInterface
public interface Runnable {
public abstract void run();
}

二、Lambda 表達式

        函數式接口的重要屬性是：咱們可以使用 Lambda 實例化它們，Lambda 表達式讓你可以將函數做爲方法參數，或者將代碼做爲數據對待。Lambda 表達式的引入給開發者帶來了很多優勢：在 Java 8 以前，匿名內部類，監聽器和事件處理器的使用都顯得很冗長，代碼可讀性不好，Lambda 表達式的應用則使代碼變得更加緊湊，可讀性加強；Lambda 表達式使並行操做大集合變得很方便，能夠充分發揮多核 CPU 的優點，更易於爲多核處理器編寫代碼；

Lambda 表達式由三個部分組成：第一部分爲一個括號內用逗號分隔的形式參數，參數是函數式接口裏面方法的參數；第二部分爲一個箭頭符號：->；第三部分爲方法體，能夠是表達式和代碼塊。語法以下：

1. 方法體爲表達式，該表達式的值做爲返回值返回。

(parameters) -> expression

2. 方法體爲代碼塊，必須用 {} 來包裹起來，且須要一個 return 返回值，但若函數式接口裏面方法返回值是 void，則無需返回值。

(parameters) -> { statements; }
例如，下面是使用匿名內部類和 Lambda 表達式的代碼比較。

下面是用匿名內部類的代碼：

button.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.print("Helllo Lambda in actionPerformed");
}
});
下面是使用 Lambda 表達式後：
button.addActionListener(
\\actionPerformed 有一個參數 e 傳入，因此用 (ActionEvent e)
(ActionEvent e)-> 
System.out.print("Helllo Lambda in actionPerformed")
);

上面是方法體包含了參數傳入 (ActionEvent e)，若是沒有參數則只需 ( )，例如 Thread 中的 run 方法就沒有參數傳入，當它使用 Lambda 表達式後：

Thread t = new Thread(
\\run 沒有參數傳入，因此用 (), 後面用 {} 包起方法體
() -> {
 System.out.println("Hello from a thread in run");
}
);
經過上面兩個代碼的比較能夠發現使用 Lambda 表達式能夠簡化代碼，並提升代碼的可讀性。
爲了進一步簡化 Lambda 表達式，可使用方法引用。例如，下面三種分別是使用內部類，使用 Lambda 表示式和使用方法引用方式的比較：
//1. 使用內部類
Function<Integer, String> f = new Function<Integer,String>(){
@Override
public String apply(Integer t) {
return null;
}
};
//2. 使用 Lambda 表達式
Function<Integer, String> f2 = (t)->String.valueOf(t); 
//3. 使用方法引用的方式
Function<Integer, String> f1 = String::valueOf;

要使用 Lambda 表達式，須要定義一個函數式接口，這樣每每會讓程序充斥着過量的僅爲 Lambda 表達式服務的函數式接口。爲了減小這樣過量的函數式接口，Java 8 在 java.util.function 中增長了很多新的函數式通用接口。例如：

Function<T, R>：將 T 做爲輸入，返回 R 做爲輸出，他還包含了和其餘函數組合的默認方法。

Predicate<T> ：將 T 做爲輸入，返回一個布爾值做爲輸出，該接口包含多種默認方法來將 Predicate 組合成其餘複雜的邏輯（與、或、非）。

Consumer<T> ：將 T 做爲輸入，不返回任何內容，表示在單個參數上的操做。

例如，People 類中有一個方法 getMaleList 須要獲取男性的列表，這裏須要定義一個函數式接口 PersonInterface：
interface PersonInterface {
 public boolean test(Person person);
}
public class People {
 private List<Person> persons= new ArrayList<Person>();
 public List<Person> getMaleList(PersonInterface filter) {
 List<Person> res = new ArrayList<Person>();
 persons.forEach(
 (Person person) -> 
 {
 if (filter.test(person)) {//調用 PersonInterface 的方法
 res.add(person);
 }
 }
 );
 return res;
 }
}
爲了去除 PersonInterface 這個函數式接口，能夠用通用函數式接口 Predicate 替代以下：
class People{
 private List<Person> persons= new ArrayList<Person>();
 public List<Person> getMaleList(Predicate<Person> predicate) {
 List<Person> res = new ArrayList<Person>();
 persons.forEach(
 person -> {
 if (predicate.test(person)) {//調用 Predicate 的抽象方法 test
 res.add(person);
 }
 });
 return res;
 }
}

 

 

三、接口的加強

        Java 8 對接口作了進一步的加強。在接口中能夠添加使用 default 關鍵字修飾的非抽象方法。還能夠在接口中定義靜態方法。現在，接口看上去與抽象類的功能愈來愈相似了。

默認方法

Java 8 還容許咱們給接口添加一個非抽象的方法實現，只須要使用 default 關鍵字便可，這個特徵又叫作擴展方法。在實現該接口時，該默認擴展方法在子類上能夠直接使用，它的使用方式相似於抽象類中非抽象成員方法。但擴展方法不可以重載 Object 中的方法。例如：toString、equals、 hashCode 不能在接口中被重載。

例如，下面接口中定義了一個默認方法 count()，該方法能夠在子類中直接使用。

public interface DefaultFunInterface {
//定義默認方法 countdefault int count(){
return 1;
}
}
public class SubDefaultFunClass implements DefaultFunInterface {
public static void main(String[] args){
//實例化一個子類對象，改子類對象能夠直接調用父接口中的默認方法 count
 SubDefaultFunClass sub = new SubDefaultFunClass();
sub.count();
}
}

靜態方法

在接口中，還容許定義靜態的方法。接口中的靜態方法能夠直接用接口來調用。

例如，下面接口中定義了一個靜態方法 find，該方法能夠直接用 StaticFunInterface .find() 來調用。

public interface StaticFunInterface {public static int find(){
return 1;
}
}
public class TestStaticFun {
public static void main(String[] args){
//接口中定義了靜態方法 find 直接被調用
StaticFunInterface.fine();
}
}

四、集合之流式操做

Stream 和 Collection 集合的區別：Collection 是一種靜態的內存數據結構，而 Stream 是有關計算的。前者是主要面向內存，存儲在內存中，後者主要是面向 CPU，經過 CPU 實現計算。

串行和並行的流

流有串行和並行兩種，串行流上的操做是在一個線程中依次完成，而並行流則是在多個線程上同時執行。並行與串行的流能夠相互切換：經過 stream.sequential() 返回串行的流，經過 stream.parallel() 返回並行的流。相比較串行的流，並行的流能夠很大程度上提升程序的執行效率。

下面是分別用串行和並行的方式對集合進行排序。

串行排序：

List<String> list = new ArrayList<String>();
for(int i=0;i<1000000;i++){
double d = Math.random()*1000;
list.add(d+"");
}
long start = System.nanoTime();//獲取系統開始排序的時間點int count= (int) ((Stream) list.stream().sequential()).sorted().count();long end = System.nanoTime();//獲取系統結束排序的時間點
long ms = TimeUnit.NANOSECONDS.toMillis(end-start);//獲得串行排序所用的時間
System.out.println(ms+」ms」);

並行排序：

List<String> list = new ArrayList<String>();
for(int i=0;i<1000000;i++){
double d = Math.random()*1000;
list.add(d+"");
}
long start = System.nanoTime();//獲取系統開始排序的時間點int count = (int)((Stream) list.stream().parallel()).sorted().count();long end = System.nanoTime();//獲取系統結束排序的時間點
long ms = TimeUnit.NANOSECONDS.toMillis(end-start);//獲得並行排序所用的時間
System.out.println(ms+」ms」);
串行輸出爲 1200ms，並行輸出爲 800ms。可見，並行排序的時間相比較串行排序時間要少很多。

中間操做

該操做會保持 stream 處於中間狀態，容許作進一步的操做。它返回的仍是的 Stream，容許更多的鏈式操做。常見的中間操做有：

filter()：對元素進行過濾；

sorted()：對元素排序；

map()：元素的映射；

distinct()：去除重複元素；

subStream()：獲取子 Stream 等。

例如，下面是對一個字符串集合進行過濾，返回以「s」開頭的字符串集合，並將該集合依次打印出來：

list.stream()
.filter((s) -> s.startsWith("s"))
.forEach(System.out::println);

這裏的 filter(...) 就是一箇中間操做，該中間操做能夠鏈式地應用其餘 Stream 操做。

終止操做

該操做必須是流的最後一個操做，一旦被調用，Stream 就到了一個終止狀態，並且不能再使用了。常見的終止操做有：

forEach()：對每一個元素作處理；

toArray()：把元素導出到數組；

findFirst()：返回第一個匹配的元素；

anyMatch()：是否有匹配的元素等。

例如，下面是對一個字符串集合進行過濾，返回以「s」開頭的字符串集合，並將該集合依次打印出來：

list.stream() //獲取列表的 stream 操做對象
.filter((s) -> s.startsWith("s"))//對這個流作過濾操做
.forEach(System.out::println);

這裏的 forEach(...) 就是一個終止操做，該操做以後不能再鏈式的添加其餘操做了。

 

五、IO/NIO的改進

Java 8 對 IO/NIO 也作了一些改進。主要包括：改進了 java.nio.charset.Charset 的實現，使編碼和解碼的效率得以提高，也精簡了 jre/lib/charsets.jar 包；優化了 String(byte[],*) 構造方法和 String.getBytes() 方法的性能；還增長了一些新的 IO/NIO 方法，使用這些方法能夠從文件或者輸入流中獲取流（java.util.stream.Stream），經過對流的操做，能夠簡化文本行處理、目錄遍歷和文件查找。

新增的 API 以下：

BufferedReader.line(): 返回文本行的流 Stream<String>

File.lines(Path, Charset):返回文本行的流 Stream<String>

File.list(Path): 遍歷當前目錄下的文件和目錄

File.walk(Path, int, FileVisitOption): 遍歷某一個目錄下的全部文件和指定深度的子目錄

File.find(Path, int, BiPredicate, FileVisitOption... ): 查找相應的文件

下面就是用流式操做列出當前目錄下的全部文件和目錄：

Files.list(new File(".").toPath())
 .forEach(System.out::println);

 

六、全球化功能

 

Java 8 版本還完善了全球化功能：支持新的 Unicode 6.2.0 標準，新增了日曆和本地化的 API，改進了日期時間的管理等。

Java 的日期與時間 API 問題由來已久，Java 8 以前的版本中關於時間、日期及其餘時間日期格式化類因爲線程安全、重量級、序列化成本高等問題而飽受批評。Java 8 吸取了 Joda-Time 的精華，以一個新的開始爲 Java 建立優秀的 API。新的 java.time 中包含了全部關於時鐘（Clock），本地日期（LocalDate）、本地時間（LocalTime）、本地日期時間（LocalDateTime）、時區（ZonedDateTime）和持續時間（Duration）的類。歷史悠久的 Date 類新增了 toInstant() 方法，用於把 Date 轉換成新的表示形式。這些新增的本地化時間日期 API 大大簡化了了日期時間和本地化的管理。

例如，下面是對 LocalDate，LocalTime 的簡單應用：

//LocalDate
LocalDate localDate = LocalDate.now(); //獲取本地日期
localDate = LocalDate.ofYearDay(2014, 200); // 得到 2014 年的第 200 天 
System.out.println(localDate.toString());//輸出：2014-07-19
localDate = LocalDate.of(2014, Month.SEPTEMBER, 10); //2014 年 9 月 10 日 
System.out.println(localDate.toString());//輸出：2014-09-10
//LocalTime
LocalTime localTime = LocalTime.now(); //獲取當前時間
System.out.println(localTime.toString());//輸出當前時間
localTime = LocalTime.of(10, 20, 50);//得到 10:20:50 的時間點
System.out.println(localTime.toString());//輸出: 10:20:50
//Clock 時鐘
Clock clock = Clock.systemDefaultZone();//獲取系統默認時區 (當前瞬時時間 )
long millis = clock.millis();//
-------------------------------------------------------------------------------------------------
寫點代碼，寫點科技。
微信公衆號「軟件開發資訊」，碰見了不妨就關注看看。