JAVA8給我帶了什麼——Optional和CompletableFuture

時間 2019-12-11

標籤 java8 java 什麼 optional completablefuture 欄目 Java 简体版

原文原文鏈接

不論是JAVA，仍是.NET。咱們經常會看到空異常(NullPointerException)。這種異常都是在運行的過程當中出現。每每是變量是一個null值。可是你引用這個變量的後繼字段或是方法。因此咱們代碼裏面經常會出現if (變量!=null)的相關操做。
若是你是一個.NET開發人員的話，那麼你必定知道.NET的能夠爲空的數據類型。一樣子java8引入了一個Optional類型，目地是爲了決解爲空帶來的一系列問題。Optional類提供了倆個靜態的方法java

of方法：建立一個非空的Optional類型。
ofNullable方法：建立一個能夠爲空的Optional類型。

讓咱們一塊兒看一下用法吧。程序員

 1 package com.aomi;
 2 
 3 import java.util.HashMap;
 4 import java.util.Map;
 5 import java.util.Optional;
 6 
 7 public class Main {
 8     private static Map<String, String> maps = new HashMap<String, String>();
 9 
10     public static void main(String[] args) {
11         // TODO Auto-generated method stub
12 
13         maps.put("aomi", "val1");
14         maps.put("key1", "val2");
15 
16         String val  = getValue("aaa");
17         
18         Optional<String> optionalVal = Optional.ofNullable(val);
19         
20         if(optionalVal.isPresent())
21         {
22             System.out.println(val.replace("a", "b"));
23         }
24         else
25         {
26             System.out.println("拿到變量值爲空");
27         }
28     }
29 
30     public static String getValue(String key) {
31         if (maps.containsKey(key))
32             return maps.get(key);
33         return null;
34     }
35 }

運行結果：網絡

isPresent方法用於判斷當前的變量是否爲空。從某意義上來說筆者以爲這好像並無多大的好處。一樣子咱們要用isPresent來判斷是否爲空。那麼跟寫if(變量!=null)有什麼分別。因此筆者打算換一換。多線程

 1 package com.aomi;
 2 
 3 import java.util.HashMap;
 4 import java.util.Map;
 5 import java.util.Optional;
 6 
 7 public class Main {
 8     private static Map<String, String> maps = new HashMap<String, String>();
 9 
10     public static void main(String[] args) {
11         // TODO Auto-generated method stub
12 
13         maps.put("aomi", "val1");
14         maps.put("key1", "val2");
15 
16         String notNullVal  = getValue("aomi");
17         String nullVal  = getValue("aaa");
18         
19         Optional<String> optNotNullVal = Optional.ofNullable(notNullVal);
20         Optional<String> optNullVal = Optional.ofNullable(nullVal);
21         
22         System.out.println(optNotNullVal.orElse("拿到變量值爲空"));
23         System.out.println(optNullVal.orElse("拿到變量值爲空"));
24     }
25 
26     public static String getValue(String key) {
27         if (maps.containsKey(key))
28             return maps.get(key);
29         return null;
30     }
31 }

上面的代碼是這樣子的。筆者拿倆個變量，一個變量是爲空的。一個不爲空。而後筆者用Optional類的orElse來作文章。顯示以下。異步

固然Optional類裏面提供了幾個用於得到值的方法。ide

get方法：就是用於得到值，若是當前的Optional類是一個有值的變量，那麼就返回值。若是沒有的話，很差意思！他會報錯。
orElse方法：表示若是爲空的話，我就返回方法給定的值。不然返回當前的值。
orElseGet方法：表示若是爲空的話，執行一個回調的方法函數。你能夠傳入一個lambda表達。
orElseThrow方法：表示若是爲空的話，回返一個異常，能夠是一個自定義的異常。

以上這些方法，筆者認爲並不能說明Optional類的特別之處。以下函數

 1 package com.aomi;
 2 
 3 import java.util.HashMap;
 4 import java.util.Map;
 5 import java.util.Optional;
 6 
 7 public class Main {
 8     private static Map<String, String> maps = new HashMap<String, String>();
 9 
10     public static void main(String[] args) {
11         // TODO Auto-generated method stub
12 
13         maps.put("aomi", "val1");
14         maps.put("key1", "val2");
15 
16         String notNullVal = getValue("aomi");
17     
18 
19         Optional<String> optNotNullVal = Optional.ofNullable(notNullVal);
20 
21         Optional<String> optNullNewVal = optNotNullVal.map(ss -> ss.replace("a", "b"));
22 
23         System.out.println(optNullNewVal.orElse("拿到變量值爲空"));
24     }
25 
26     public static String getValue(String key) {
27         if (maps.containsKey(key))
28             return maps.get(key);
29         return null;
30     }
31 }

運行結果：性能

咱們能夠到Optional類提供了一個map方法。這個功能跟之前講到的流的map有一點相似。大家能夠看到筆者在上面經過map方法來把'a'字符替換爲‘b’。最後val1變成爲vbl1。若是筆者還想把‘l‘替換爲’r‘。後面在增長一個Map以下測試

Optional<String> optNullNewVal = optNotNullVal.map(ss -> ss.replace("a", "b")).map(ss->ss.replace("l","r"));

即然有map方法了。是否是也主是有filter方法。沒有錯。還真的有。以下。spa

 1 package com.aomi;
 2 
 3 import java.util.HashMap;
 4 import java.util.List;
 5 import java.util.Map;
 6 import java.util.Optional;
 7 
 8 public class Main {
 9     private static Map<String, String> maps = new HashMap<String, String>();
10 
11     public static void main(String[] args) {
12         // TODO Auto-generated method stub
13 
14         maps.put("aomi", "vbl1");
15         maps.put("key1", "val2");
16     
17         String notNullVal = getValue("aomi");
18 
19         Optional<String> optNotNullVal = Optional.ofNullable(notNullVal);
20 
21         Optional<String> optNullNewVal = optNotNullVal.filter( ss->ss.contains("a")).map(ss->ss.replace("a", "b"));
22 
23         System.out.println(optNullNewVal.orElse("拿到變量值爲空"));
24     }
25 
26     public static String getValue(String key) {
27         
28         if(maps.containsKey(key))
29             return maps.get(key);
30         return "map";
31     }
32 }

筆者找出含有’a‘字符的字串符。而後"a"替換 "b"。主要修改代碼倆個地方。以下

1.把val1修改成vbl1。主要是讓他有值，卻不含有'a'字符。了爲證實他能夠過濾掉有‘a’的字符串

maps.put("aomi", "vbl1");

2.增長filter方法進行過濾。條件必須含有'a'

.filter( ss->ss.contains("a"))

運行結果：

JAVA爲了空值的問題增長了Optional類。提功能了一系列功能。你們能夠試着用用感受如何。

筆者記得好像是在JAVA5的時候，JAVA引一個Future接口。若是你沒有印像的話，那大家有沒有用到過FutureTask類呢。之前要建立一個多線程的話，通常有倆種。一種是繼承Thread;一種是實現Runnable

 1 package com.aomi;
 2 
 3 public class Main {
 4 
 5     public static void main(String[] args) {
 6         // TODO Auto-generated method stub
 7 
 8         Thread th1 = new Thread() {
 9             @Override
10             public void run() {
11                 System.out.println("這是一個Thread副線程");
12             }
13         };
14         
15         th1.start();
16         
17         
18         Thread th2 = new Thread(new Runnable() {
19             
20             @Override
21             public void run() {
22                 System.out.println("這是一個Runnable副線程");
23             }
24         });
25         
26         th2.start();
27         
28         try {
29             Thread.sleep(2000);
30         } catch (InterruptedException e) {
31             // TODO Auto-generated catch block
32             e.printStackTrace();
33         }
34         
35         System.out.println("這是一個主線程");
36     }
37 
38 }

運行結果：

咱們能夠看到代碼中的倆種方式了吧。這倆個方式都只有一個毛病。沒有辦法實現返回值的功能。因此引入了Future接口。以下

 1 package com.aomi;
 2 
 3 import java.util.concurrent.Callable;
 4 import java.util.concurrent.ExecutionException;
 5 import java.util.concurrent.FutureTask;
 6 
 7 public class Fmain {
 8     public static void main(String[] args) {
 9 
10         FutureTask<String> task = new FutureTask<>(new Callable<String>() {
11             @Override
12             public String call() throws Exception {
13                 Thread.sleep(1000);
14                 return "i am aomi";
15             }
16         });
17 
18         new Thread(task).start();
19 
20         try {
21             System.out.println("主線程： 結果=" + task.get());
22         } catch (InterruptedException e) {
23             // TODO Auto-generated catch block
24             e.printStackTrace();
25         } catch (ExecutionException e) {
26             // TODO Auto-generated catch block
27             e.printStackTrace();
28         }
29 
30     }
31 }

運行結果：

我能夠看到一個叫Callable接口。是裏面的call方法和Runnable方法有一點像。只是一個有返回值，一個沒有。FutureTask類同時也提了不少方法。好比上的代碼筆者在改改。加入判斷是否取消了。若是沒有取消的話，就取消掉他。而後也去獲取他的值。

 1 package com.aomi;
 2 
 3 import java.util.concurrent.Callable;
 4 import java.util.concurrent.ExecutionException;
 5 import java.util.concurrent.FutureTask;
 6 
 7 public class Fmain {
 8     public static void main(String[] args) {
 9 
10         FutureTask<String> task = new FutureTask<>(new Callable<String>() {
11             @Override
12             public String call() throws Exception {
13                 Thread.sleep(1000);
14                 System.out.println("副線程：返回值=i am aomi");
15                 return "i am aomi";
16             }
17         });
18 
19         new Thread(task).start();
20 
21         try {
22             if (!task.isCancelled())
23             {
24                 task.cancel(true);
25                 System.out.println("取消副線程");
26                 System.out.println("主線程： 結果=" + task.get());
27             }
28             else
29             {
30                 System.out.println("主線程： 結果=" + task.get());
31             }
32                 
33         } catch (InterruptedException e) {
34             // TODO Auto-generated catch block
35             e.printStackTrace();
36         } catch (ExecutionException e) {
37             // TODO Auto-generated catch block
38             e.printStackTrace();
39         }
40 
41     }
42 }

運行結果：

看到了沒有被取消了。同時你去得到取消線程的結果時，會發生異常。有沒有.NET的程序員，感受像不像.NET的任務(Task)。事實上有上面的功能大部業務均可以實現了。可是JAVA8仍是又引一個叫CompletableFuture類。相對於Future接口增長了不少方法。以下得到異步裏面的結果。

 1 package com.aomi;
 2 
 3 import java.util.concurrent.CompletableFuture;
 4 import java.util.concurrent.ExecutionException;
 5 
 6 public class Cmain {
 7 
 8     public static void main(String[] args) {
 9         // TODO Auto-generated method stub
10         
11         CompletableFuture<String> future = new CompletableFuture<>();
12         
13         new Thread(new Runnable() {
14             
15             @Override
16             public void run() {
17                 
18                 try {
19                     Thread.sleep(2000);
20                 } catch (InterruptedException e) {
21                     // TODO Auto-generated catch block
22                     e.printStackTrace();
23                 }
24                 
25                 future.complete("i am a CompletableFuture");
26                 
27             }
28         }).start();
29         
30         
31         try {
32             
33             System.out.println(future.get());
34             
35         } catch (InterruptedException e) {
36             // TODO Auto-generated catch block
37             e.printStackTrace();
38         } catch (ExecutionException e) {
39             // TODO Auto-generated catch block
40             e.printStackTrace();
41         }
42 
43     }
44 
45 }

運行結果：

筆者在線程裏面睡了2000秒。因此大家運行之個例子的時候，會發現慢了2秒才顯示結果。說明future.get()會等線程的結果。事實上FutureTask類也是同樣子。因此CompletableFuture類提供一系列的功能組合。只要設計好的話，性能會提升不少。

 1 package com.aomi;
 2 
 3 import java.util.concurrent.CompletableFuture;
 4 import java.util.concurrent.ExecutionException;
 5 import java.util.concurrent.Executor;
 6 import java.util.concurrent.Executors;
 7 import java.util.concurrent.ThreadFactory;
 8 
 9 public class Dmain {
10 
11     public static void main(String[] args) {
12         // TODO Auto-generated method stub
13 
14         CompletableFuture<String> oneFuture = CompletableFuture.supplyAsync(() -> {
15 
16             System.out.println("supplyAsync用於新建");
17             return "2011";
18         });
19 
20         CompletableFuture<Long> twoFuture = oneFuture.thenApply((ss) -> {
21             System.out.println("thenApply用於轉化");
22             return Long.parseLong(ss);
23         });
24 
25         CompletableFuture<Long> threeFuture = twoFuture.thenCompose(val -> {
26             System.out.println("thenCompose用於組合倆個CompletableFuture，可是依賴上一個CompletableFuture");
27             try {
28                 Thread.sleep(2000);
29             } catch (InterruptedException e) {
30                 // TODO Auto-generated catch block
31                 e.printStackTrace();
32             }
33 
34             return CompletableFuture.supplyAsync(() -> 
35             {
36                 long result = val * 2;
37                 System.out.println("thenCompose的結果是："+ result);
38                 return result;
39             }
40             
41             );
42         });
43 
44         CompletableFuture<String> otherFuture = CompletableFuture.supplyAsync(() -> {
45             System.out.println("用於thenCombine的測試  上面的結果+4");
46             return "4";
47         });
48 
49         CompletableFuture<Long> finalFuture = threeFuture.thenCombine(otherFuture, (arg1, arg2) -> {
50             return arg1 + Long.parseLong(arg2);
51         });
52 
53         finalFuture.thenAccept((ss) -> {
54             System.out.println("thenAccept用於處理相關的結果數據");
55         });
56 
57         finalFuture.thenRun(() -> {
58             System.out.println("thenRun用於異步完成，執行相關的操做");
59         });
60 
61         try {
62             
63             System.out.println(finalFuture.get());
64         } catch (InterruptedException e) {
65             // TODO Auto-generated catch block
66             e.printStackTrace();
67         } catch (ExecutionException e) {
68             // TODO Auto-generated catch block
69             e.printStackTrace();
70         }
71 
72     }
73 
74 }

運行結果:

這個個方法的做用筆者略微的列了出來。想要加深的話，大家可能最好在去找一些資料。關於CompletableFuture的教程網絡上不少。

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。