Optional类型

阳光穿透心脏的1/2处 2021-08-28 02:05 390阅读 0赞

### Optional类型 ###

`optional<T>`对象是一种包装器对象，要么包装了类型T对象，要么没有包装任何对象。对于第一种情况，称这种值为存在的。Optional<T>类型被当做一种更安全的方式，用来替代类型T的引用，这种引用要么引用某个对象，要么为null。但是，它只有在正确使用的情况下才会更安全。

#### 使用Optional值 ####

有效地使用Optional的关键是要使用这样的方法：它在值不存在的情况下会产生一个可替代物品，而只有在值存在的情况下才会使用这个值。

**通常，在没有任何匹配时，我们会希望使用某种默认值，可能是空字符串：**

String result = optionalString.orElse("");
    //The wrapped string, or "" if none

**你还可以调用代码来计算默认值：**

String result = optionlString.orElseGet(() -> Locale.getDefault().getDisplayName());
    //The function is only called when needed

**或者可以在没有任何值时抛出异常：**

String result = optionalString.orElseThrow(IllegalAccessException::new);

另一种使用可选值的策略是只有在其存在的情况下才消费该值。

**ifPresent方法会接受一个函数。如果该可选值存在，那么它会被传递给该函数。否则，不会发生任何事情：**

optionalString.ifPresent(v -> Process v);

**如果在该值存在的情况下想要将其添加到某个集中，那么就可以调用：**

optionalString.ifPresent(v -> results.add(v));

**或者直接调用：**

optionalString.ifPresent(results::add);

当调用ifPresent时，从该函数不会返回任何值。如果想要处理函数的结果，应该使用map：

Optional<Boolean> added = optionalString.map(results::add);

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>T orElse(T other)</code></td> 
   <td align="left">产生这个Optional的值，或者在该Optional为空时，产生other</td> 
  </tr> 
  <tr> 
   <td align="left"><code>T orElseGet(Supplier&lt;? extends T&gt; other)</code></td> 
   <td align="left">产生这个Optional的值，或者在该Optional为空时，调用other的结果</td> 
  </tr> 
  <tr> 
   <td align="left"><code>&lt;X extends Throwabled&gt; T orElseThrow(Supplier&lt;? extends X&gt; exceptionSupplier)</code></td> 
   <td align="left">产生这个Optional的值，或者在该Optional为空时，抛出调用exceptionSupplier的结果</td> 
  </tr> 
  <tr> 
   <td align="left"><code>void ifPresent(Consumer&lt;? super T&gt; consumer)</code></td> 
   <td align="left">如果该Optional不为空，那么就将它的值传递给consumer</td> 
  </tr> 
  <tr> 
   <td align="left"><code>&lt;U&gt; Optional&lt;U&gt; map(Function&lt;? super T, ? extends U&gt; mapper)</code></td> 
   <td align="left">产生将该Optional的值传递给mapper后的结果，只要这个Optional不为空且结果不为null，否则产生一个空Optional。</td> 
  </tr> 
 </tbody> 
</table>

#### 不适合使用Optional值的方式 ####

get方法会在Optional值存在的情况下获得其中包装的元素，或者在不存在的情况下抛出一个NoSuchElementException对象。因此：

Optional<T> optionalValue = ...;
    optionalValue.get().someMethod();
    
    //并不比下面的方式更安全
    
    T value = ...;
    value.someMethod();

ifPresent方法会报告某个Optional<T>对象是否具有一个值，但是

if(optionalValue.isPresent())
    	optionalValue.get().someMethod();
    
    //并不比下面的方法更容易处理
    
    if(value != null)
    	value.someMethod();

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>T get()</code></td> 
   <td align="left">产生这个Optional的值，或者在该Optional为空时，抛出一个NoSuchElementException</td> 
  </tr> 
  <tr> 
   <td align="left"><code>boolean isPresent()</code></td> 
   <td align="left">如果该Optional不为空，则返回true</td> 
  </tr> 
 </tbody> 
</table>

#### 创建Optional值 ####

**Optional.of(result) 和 Optional.empty()**

public static Optional<Double> inverse(Double x) { 
            return x == 0 ? Optional.empty() : Optional.of(1 / x);
        }

**ofNullable方法被用啦作为可能出现的null值和可选值之间的桥梁：**

Optional.ofNullable(obj)会在obj不为null的情况下返回Optional.of(obj)，否则会返回Optional.empty()。

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>static &lt;T&gt; Optional&lt;T&gt; of(T value)</code><br><code>static &lt;T&gt; Optional&lt;T&gt; ofNullable(T value)</code></td> 
   <td align="left">产生一个具有给定值的Optional。如果value为null，那么第一个方法抛出一个具有给定值的NullPointerExcepion对象，而第二个方法会产生一个空optional。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>static &lt;T&gt; Optional&lt;T&gt; empty()</code></td> 
   <td align="left">产生一个空Optional。</td> 
  </tr> 
 </tbody> 
</table>

#### 利用flatMap来构建Optional值的函数 ####

假如有一个可以产生Optional对象的方法f、并且目标类型T具有一个可以产生Optional对象的方法g。如果他们都是普通的方法，那么你可以通过调用s.f().g()来将他们组合起来。但是这种组合没法工作，因为s.f()的类型为Optional<T>，而不是T。因此，需要调用：

Optional<U> result = s.f().flatMap(T::G);

如果s.f()的值存在，那么g就可以应用到它上面。否则，就会返回一个空Optional。

很明显，如果有更多的可以产生Optional值的方法或Lambda表达式，那么就可以重复此过程。你可以直接将flatMap的调用链接起来，从而构建由这些步骤构成的管道，只有所有步骤都成功时，该管段才会成功。

package pers.zhang;
    
    import java.util.*;
    
    /** * @Author: acton_zhang * @Date: 2020/3/25 11:49 上午 * @Version 1.0 */
    public class OptionalTest { 
        public static void main(String[] args) { 
            String[] strs = { "one", "two", "three", "four", "five"};
            List<String> wordList = Arrays.asList(strs);
    
            Optional<String> o = wordList.stream().filter(s -> s.contains("o")).findFirst();
            System.out.println(o.orElse("No word contains o"));
    
    
            Optional<String> optionalString = Optional.empty();
            String result = optionalString.orElse("N/A");
            System.out.println("result:" + result);
            result = optionalString.orElseGet(() -> Locale.getDefault().getDisplayName());
            System.out.println("result:" + result);
    
            try { 
                result = optionalString.orElseThrow(IllegalAccessException::new);
                System.out.println("result:" + result);
            } catch (IllegalAccessException e) { 
                e.printStackTrace();
            }
    
            optionalString  = wordList.stream().filter(s -> s.contains("e")).findFirst();
            optionalString.ifPresent(s -> System.out.println(s + "contains e"));
    
            Set<String> results = new HashSet<>();
            optionalString.ifPresent(results::add);
            Optional<Boolean> added = optionalString.map(results::add);
            System.out.println(added);
    
            System.out.println(inverse(4.0).flatMap(OptionalTest::squareRoot));
            System.out.println(inverse(-1.0).flatMap(OptionalTest::squareRoot));
            System.out.println(inverse(0.0).flatMap(OptionalTest::squareRoot));
            Optional<Double> result2 = Optional.of(-4.0)
                    .flatMap(OptionalTest::inverse)
                    .flatMap(OptionalTest::squareRoot);
            System.out.println(result2);
    
        }
    
    
        public static Optional<Double> inverse(Double x) { 
            return x == 0 ? Optional.empty() : Optional.of(1 / x);
        }
    
        public static Optional<Double> squareRoot(Double x) { 
            return x < 0 ? Optional.empty() : Optional.of(Math.sqrt(x));
        }
    }