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