Java SE 8 流库（三）

1.7. Optional类型

容器对象，可能包含或不包含非空值。如果存在一个值，isPresent()将返回true，get()将返回值。还提供了依赖于包含值是否存在的附加方法，如orElse()(如果值不存在则返回一个默认值)以及ifPresent()(如果该值存在，则执行一个代码块)。

1.7.1. 如何使用Optional值

它的值不存在的情况下会产生一个可代替物，而只有值存在的情况下才会使用这个值；

public T orElse(T other)               返回值如果存在，否则返回其他。

 public T orElse(T other) {
         return value != null ? value : other;
 }

public static <T> Optional<T> empty()  返回一个空的可选实例

 private static final Optional<?> EMPTY = new Optional<>();
 public static<T> Optional<T> empty() {
         Optional<T> t = (Optional<T>) EMPTY;
         return t;
 }

public T orElseGet(Supplier<? extends T> other)   如果当前值存在就返回该值，否则调用其他值并返回该调用的结果。

 public T orElseGet(Supplier<? extends T> other) {
         return value != null ? value : other.get();
 }

public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X extends Throwable       返回包含的值（如果存在），否则抛出由供应商创建的异常。

 public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
         if (value != null) {
             return value;
         } else {
             throw exceptionSupplier.get();
         }
     }

public <U> Optional<U> map(Function<? super T,? extends U> mapper)    如果存在值，则应用提供的映射函数，如果结果不为空，则返回一个描述结果的可选项。否则返回一个空的可选。

 public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
         Objects.requireNonNull(mapper);
         if (!isPresent())
             return empty();
         else {
             return Optional.ofNullable(mapper.apply(value));
         }
     }

public void ifPresent(Consumer<? super T> consumer)    如果存在值，则使用该值调用指定的消费者，否则不执行任何操作

 public void ifPresent(Consumer<? super T> consumer) {
         if (value != null)
             consumer.accept(value);
 }

1.7.2. 实例

 public class Demo09 {

     private static final String filePath = "G:\\Idea\\src\\com\\itheima05\\Test_JavaSE\\Test_20171214\\word.txt";

     public static void main(String[] args) throws Exception {

         String contens = new String(Files.readAllBytes(Paths.get(filePath)), StandardCharsets.UTF_8);
         List<String> words = Arrays.asList(contens.split("\\PL+"));

         //获取流中的最大值,(忽略大小写)
         Optional<String> maxValue = words.stream().max(String::compareToIgnoreCase);
         System.out.println("maxValue:"+maxValue.orElse(""));

         //orElse实例
         Optional<String>  firstWord = words.stream()
                 .filter(w -> w.contains("pro"))
                 .findFirst();
         System.out.println(firstWord.orElse("No word" + "contains pro"));

         //empty:返回一个空的可选实例(optionalValue == null)
         Optional<String> optionalValue = firstWord.empty();
         String orElseValue = optionalValue.orElse("N/A");
         System.out.println("orElseValue:"+orElseValue);

         //orElseGet实例
         String orElseGetValue = optionalValue.orElseGet(() -> Locale.getDefault().getDisplayName());
         System.out.println("orElseGetValue:"+orElseGetValue);

         //orElseThrow实例
         try {
             String orElseThrowValue = optionalValue.orElseThrow(IllegalStateException::new);
             System.out.println("orElseThrowValue:"+orElseThrowValue);
         } catch (Throwable e) {
             e.printStackTrace();
         }

         //ifPresent实例
         Optional<String> ifPresentValue = words.stream().filter(w -> w.contains("Quite")).findFirst();
         ifPresentValue.ifPresent(s -> System.out.println("s:" + "contains Quite"));

         HashSet<String> results = new HashSet<>();
         ifPresentValue.ifPresent(results :: add);

         //调用ifPresent时,从该函数不会返回任何值,如果想要处理函数的结果,应该使用map
         Optional<Boolean> mapValue = ifPresentValue.map(results::add);
         Optional<Integer> sizeValue = ifPresentValue.map(s -> results.size());
         Optional<String> iteratorValue = ifPresentValue.map(s -> results.iterator().next());
         System.out.println("mapValue:"+mapValue);
         System.out.println("sizeValue:"+sizeValue);
         System.out.println("iteratorValue:"+iteratorValue);
         //mapValue具有三种值:在ifPresentValue存在的情况下包装在Optional中的true或false,
         //以及ifPresentValue不存在的情况下的空Optional
     }
 }

1.7.3. 不适合使用Optional值的方式

public T get()         如果此可选中存在值，则返回该值，否则引发NoSuchElementException;

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

public boolean isPresent()  如果该Optional不为空，则返回true;

 public class Demo10 {

     private static final String filePath = "G:\\Idea\\src\\com\\itheima05\\Test_JavaSE\\Test_20171214\\word.txt";

     public static void main(String[] args) throws Exception {

         String contens = new String(Files.readAllBytes(Paths.get(filePath)), StandardCharsets.UTF_8);
         List<String> words = Arrays.asList(contens.split("\\PL+"));
         Optional<String> word = words.stream().filter(w -> w.contains("Quite")).findFirst();
         if(word.isPresent()){
             String w = word.get().toUpperCase();
             System.out.println(w);
         }else{
             String orElseValue = word.orElse("not contains Quite");
             System.out.println("orElseValue:"+orElseValue);
         }
     }
 }

1.7.4. 创建Optional值

public static <T> Optional<T> ofNullable(T value)    该方法被用来作为可能出现的null值和可选值之间的桥梁，Optional. ofNullable(obj)会在obj不为null的情况下返回Optional.of(obj)，否则会返回Optional.empty();

public static <T> Optional<T> of(T value)                返回指定的当前非空值的Optional。

public static <T> Optional<T> empty()                      返回一个空的可选实例。 没有值是这个可选的。

 public class Demo11 {

 public static void main(String[] args) {

         //Optional.ofNullable(obj):obj不为空,返回一个Optional.of(obj)
         String s = "123";
         Optional<String> s1 = Optional.ofNullable(s);
         System.out.println(s1);       //输出:Optional[123]
         //Optional.ofNullable(obj):obj为空,返回一个Optional.empty();
         String ss1 = "";
         Optional<String> ss = Optional.ofNullable(ss1);
         System.out.println(ss);       //输出:Optional[]
     }
 }

1.7.5. 用faltMAP来构建Optional值的函数

假设你有一个可以产生Optional<T>对象的方法F，并且目标类型T具有一个可以产生Optional<U>对象的方法G；如果都是普通的方法，那么可以通过调用s.f().g()来将他们组合起来，但是这种组合没法工作；

需要这样调用：

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

 public class Demo12 {

     public static void main(String[] args) {

         //Demo12 :: squareRoot,这种格式表示:Demo12类中名为squareRoot的方法
         Optional<Double> result = inverse(2.0).flatMap(Demo12 :: squareRoot);
         if(result.isPresent()){
             Double orElseValue = result.orElse(0.0);
             System.out.println("orElseValue:"+orElseValue);
         }

         //实例2
         System.out.println("实例1:"+inverse(4.0).flatMap(Demo12 :: squareRoot));
         System.out.println("实例2:"+inverse(-1.0).flatMap(Demo12 :: squareRoot));
         System.out.println("实例3:"+inverse(0.0).flatMap(Demo12 :: squareRoot));

         System.out.println("实例4:"+Optional.of(-0.4).flatMap(Demo12 :: inverse).flatMap(Demo12 :: squareRoot));
     }

     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));
     }
 }