Java核心技术卷2——Optional包装器

一、主要方法

1、optional.orElse(other)，产生值，为空产生other。

2、optional.orElseGet(other),产生值，为空产生other的结果。

3、optional.map()，产生optional的值传递给mapper后的结果，optional不为空，不为null，否则产生空optional。

4、optional.ifPresent(consume);如果值不为空，传递给consume

二、创建optional

1、Optional.of()

2、Optional.empty()

三、示例代码

package com.com.yt;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.*;

public class OptionalTest {
    public static void main(String[] args) throws IOException {
        String contents = new String(Files.readAllBytes(Paths.get("G:/testtxt/alice.txt")), StandardCharsets.UTF_8);
        List<String> wordList = Arrays.asList(contents.split("\\PL+"));

        //创建一个流。.stream方法就是创建流的方法。
        /*
        * 创建一个包装器对象，对象的类型是String，把文件作为流赋值给，String类型的包装器对象，调用方法看是否包含For这个单词。第一个。
        * */
        Optional<String> optionalValue =wordList.stream()
                .filter(s -> s.contains("for"))
                .findFirst();

        /*
        *T orElse(T other)
        * 产生这个Optional的值，或者在该Optional为空时，产生other。
        * 本程序的other就是字符串："no word"
        */
        System.out.println(optionalValue.orElse("no word ")+"contains fred");

        /*
        * 这个optional翻译为：可选择。包装器对象。
        * 创建了一个空的包装器：Optional.empty();
        * 这个空的包装器赋给optionalString，
        * 调用了optionalString.orElse()不为空产生值,如果结果为空的话，就会调用orElse("N/A");
        * */
        Optional<String> optionalString = Optional.empty();
        String result = optionalString.orElse("N/A");
        System.out.println("result:"+result);

        //optionalString为空，就会调用orElse(表达式);
        result = optionalString.orElseGet(()-> Locale.getDefault().getDisplayName());
        System.out.println("result试一试:"+result);

        try {
            result = optionalString.orElseThrow(IllegalStateException::new);
            System.out.println("result是:"+result);
        } catch (Throwable e) {
            e.printStackTrace();
        }
        /*
        * 作为一个流的子流，过滤出来了A，并这个结果赋值给了optionalValue。
        * optionalValue调用Optional的方法，判断这个包装器对象是否为空，不为空就把值传递给后面的函数
        * lambda表达式
        * */
        optionalValue = wordList.stream().filter(s -> s.contains("A")).findFirst();
        optionalValue.ifPresent(s -> System.out.println(s+" contains A"));

        /*
        * 想要输出结果就用map
        * 想要函数处理的结果
        * */
        Set<String> results = new HashSet<>();
        optionalValue.ifPresent(results::add);
        Optional<Boolean> added = optionalValue.map(results::add);
        System.out.println("map的结果"+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);
    }

    //创建一个静态方法。产生optional对象实例。
    public static Optional<Double> inverse(Double x){
        return x == 0 ? Optional.empty() : Optional.of(1/x);
    }
    //创建一个静态方法。产生optional对象实例。
    public static Optional<Double> squareRoot(Double x){
        return x < 0 ? Optional.empty() : Optional.of(Math.sqrt(x));
    }
}