JAVA8给我带了什么——Optional和CompletableFuture

不管是JAVA，还是.NET。我们常常会看到空异常(NullPointerException)。这种异常都是在运行的过程中出现。往往是变量是一个null值。但是你引用这个变量的后继字段或是方法。所以我们代码里面常常会出现if (变量!=null)的相关操作。
如果你是一个.NET开发人员的话，那么你一定知道.NET的可以为空的数据类型。同样子java8引入了一个Optional类型，目地是为了决解为空带来的一系列问题。Optional类提供了俩个静态的方法

• of方法：创建一个非空的Optional类型。
• ofNullable方法：创建一个可以为空的Optional类型。

让我们一起看一下用法吧。

 package com.aomi;

 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;

 public class Main {
     private static Map<String, String> maps = new HashMap<String, String>();

     public static void main(String[] args) {
         // TODO Auto-generated method stub

         maps.put("aomi", "val1");
         maps.put("key1", "val2");

         String val  = getValue("aaa");

         Optional<String> optionalVal = Optional.ofNullable(val);

         if(optionalVal.isPresent())
         {
             System.out.println(val.replace("a", "b"));
         }
         else
         {
             System.out.println("拿到变量值为空");
         }
     }

     public static String getValue(String key) {
         if (maps.containsKey(key))
             return maps.get(key);
         return null;
     }
 }

运行结果：

isPresent方法用于判断当前的变量是否为空。从某意义上来讲笔者觉得这好像并没有多大的好处。同样子我们要用isPresent来判断是否为空。那么跟写if(变量!=null)有什么分别。所以笔者打算换一换。

 package com.aomi;

 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;

 public class Main {
     private static Map<String, String> maps = new HashMap<String, String>();

     public static void main(String[] args) {
         // TODO Auto-generated method stub

         maps.put("aomi", "val1");
         maps.put("key1", "val2");

         String notNullVal  = getValue("aomi");
         String nullVal  = getValue("aaa");

         Optional<String> optNotNullVal = Optional.ofNullable(notNullVal);
         Optional<String> optNullVal = Optional.ofNullable(nullVal);

         System.out.println(optNotNullVal.orElse("拿到变量值为空"));
         System.out.println(optNullVal.orElse("拿到变量值为空"));
     }

     public static String getValue(String key) {
         if (maps.containsKey(key))
             return maps.get(key);
         return null;
     }
 }

上面的代码是这样子的。笔者拿俩个变量，一个变量是为空的。一个不为空。然后笔者用Optional类的orElse来做文章。显示如下。

当然Optional类里面提供了几个用于获得值的方法。

• get方法：就是用于获得值，如果当前的Optional类是一个有值的变量，那么就返回值。如果没有的话，不好意思！他会报错。
• orElse方法：表示如果为空的话，我就返回方法给定的值。否则返回当前的值。
• orElseGet方法：表示如果为空的话，执行一个回调的方法函数。你可以传入一个lambda表达。
• orElseThrow方法：表示如果为空的话，回返一个异常，可以是一个自定义的异常。

以上这些方法，笔者认为并不能说明Optional类的特别之处。如下

 package com.aomi;

 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;

 public class Main {
     private static Map<String, String> maps = new HashMap<String, String>();

     public static void main(String[] args) {
         // TODO Auto-generated method stub

         maps.put("aomi", "val1");
         maps.put("key1", "val2");

         String notNullVal = getValue("aomi");

         Optional<String> optNotNullVal = Optional.ofNullable(notNullVal);

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

         System.out.println(optNullNewVal.orElse("拿到变量值为空"));
     }

     public static String getValue(String key) {
         if (maps.containsKey(key))
             return maps.get(key);
         return null;
     }
 }

运行结果：

我们可以到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方法。没有错。还真的有。如下。

 package com.aomi;

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;

 public class Main {
     private static Map<String, String> maps = new HashMap<String, String>();

     public static void main(String[] args) {
         // TODO Auto-generated method stub

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

         String notNullVal = getValue("aomi");

         Optional<String> optNotNullVal = Optional.ofNullable(notNullVal);

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

         System.out.println(optNullNewVal.orElse("拿到变量值为空"));
     }

     public static String getValue(String key) {

         if(maps.containsKey(key))
             return maps.get(key);
         return "map";
     }
 }

笔者找出含有’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

 package com.aomi;

 public class Main {

     public static void main(String[] args) {
         // TODO Auto-generated method stub

         Thread th1 = new Thread() {
             @Override
             public void run() {
                 System.out.println("这是一个Thread副线程");
             }
         };

         th1.start();

         Thread th2 = new Thread(new Runnable() {

             @Override
             public void run() {
                 System.out.println("这是一个Runnable副线程");
             }
         });

         th2.start();

         try {
             Thread.sleep(2000);
         } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }

         System.out.println("这是一个主线程");
     }

 }

运行结果：

我们可以看到代码中的俩种方式了吧。这俩个方式都只有一个毛病。没有办法实现返回值的功能。所以引入了Future接口。如下

 package com.aomi;

 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.FutureTask;

 public class Fmain {
     public static void main(String[] args) {

         FutureTask<String> task = new FutureTask<>(new Callable<String>() {
             @Override
             public String call() throws Exception {
                 Thread.sleep(1000);
                 return "i am aomi";
             }
         });

         new Thread(task).start();

         try {
             System.out.println("主线程： 结果=" + task.get());
         } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         } catch (ExecutionException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }

     }
 }

运行结果：

我可以看到一个叫Callable接口。是里面的call方法和Runnable方法有一点像。只是一个有返回值，一个没有。FutureTask类同时也提了很多方法。比如上的代码笔者在改改。加入判断是否取消了。如果没有取消的话，就取消掉他。然后也去获取他的值。

 package com.aomi;

 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.FutureTask;

 public class Fmain {
     public static void main(String[] args) {

         FutureTask<String> task = new FutureTask<>(new Callable<String>() {
             @Override
             public String call() throws Exception {
                 Thread.sleep(1000);
                 System.out.println("副线程：返回值=i am aomi");
                 return "i am aomi";
             }
         });

         new Thread(task).start();

         try {
             if (!task.isCancelled())
             {
                 task.cancel(true);
                 System.out.println("取消副线程");
                 System.out.println("主线程： 结果=" + task.get());
             }
             else
             {
                 System.out.println("主线程： 结果=" + task.get());
             }

         } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         } catch (ExecutionException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }

     }
 }

运行结果：

看到了没有被取消了。同时你去获得取消线程的结果时，会发生异常。有没有.NET的程序员，感觉像不像.NET的任务(Task)。 事实上有上面的功能大部业务都可以实现了。但是JAVA8还是又引一个叫CompletableFuture类。相对于Future接口增加了很多方法。如下获得异步里面的结果。

 package com.aomi;

 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;

 public class Cmain {

     public static void main(String[] args) {
         // TODO Auto-generated method stub

         CompletableFuture<String> future = new CompletableFuture<>();

         new Thread(new Runnable() {

             @Override
             public void run() {

                 try {
                     Thread.sleep(2000);
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }

                 future.complete("i am a CompletableFuture");

             }
         }).start();

         try {

             System.out.println(future.get());

         } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         } catch (ExecutionException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }

     }

 }

运行结果：

笔者在线程里面睡了2000秒。所以你们运行之个例子的时候，会发现慢了2秒才显示结果。说明future.get()会等线程的结果。事实上FutureTask类也是一样子。所以CompletableFuture类提供一系列的功能组合。只要设计好的话，性能会提高很多。

 package com.aomi;

 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadFactory;

 public class Dmain {

     public static void main(String[] args) {
         // TODO Auto-generated method stub

         CompletableFuture<String> oneFuture = CompletableFuture.supplyAsync(() -> {

             System.out.println("supplyAsync用于新建");
             return "2011";
         });

         CompletableFuture<Long> twoFuture = oneFuture.thenApply((ss) -> {
             System.out.println("thenApply用于转化");
             return Long.parseLong(ss);
         });

         CompletableFuture<Long> threeFuture = twoFuture.thenCompose(val -> {
             System.out.println("thenCompose用于组合俩个CompletableFuture，但是依赖上一个CompletableFuture");
             try {
                 Thread.sleep(2000);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }

             return CompletableFuture.supplyAsync(() ->
             {
                 long result = val * 2;
                 System.out.println("thenCompose的结果是："+ result);
                 return result;
             }

             );
         });

         CompletableFuture<String> otherFuture = CompletableFuture.supplyAsync(() -> {
             System.out.println("用于thenCombine的测试  上面的结果+4");
             return "4";
         });

         CompletableFuture<Long> finalFuture = threeFuture.thenCombine(otherFuture, (arg1, arg2) -> {
             return arg1 + Long.parseLong(arg2);
         });

         finalFuture.thenAccept((ss) -> {
             System.out.println("thenAccept用于处理相关的结果数据");
         });

         finalFuture.thenRun(() -> {
             System.out.println("thenRun用于异步完成，执行相关的操作");
         });

         try {

             System.out.println(finalFuture.get());
         } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         } catch (ExecutionException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }

     }

 }

运行结果:

这个个方法的作用笔者略微的列了出来。想要加深的话，你们可能最好在去找一些资料。关于CompletableFuture的教程网络上很多。