java 随笔 java.util.Optional

0. 强调‘面对对象编程’的封装类

java.util.Optional
java lambda 表达式的局部变量为什么必须是final修饰？

gitee中的simple code

---

不得不说,这一块guava做了不少有意思的事情…

1. 走读源码的同时也会领悟到其中的用心

/*
 * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
package java.util;

// 可以猜想到Optional 将接受来自 jdk8新特性的 lambda + stream api 的"馈赠"
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

// 总的来说,源码比较简单易懂,重点还是恰到好处的应用到项目中
// 可以帮助我们,更加轻易的摆脱"面对过程"的逻辑代码
// 这也是为什么guava将旧版本的Objects工具类的api基本上都给拿掉
public final class Optional<T> {
    
	// 默认的、空白的、静态的 对象副本
    private static final Optional<?> EMPTY = new Optional<>();
	// "主角"实例
    private final T value;

	/********************** 实例构造的方式 **********************/

    // 俩 私有的构造
    private Optional() {this.value = null;}
	/**
     * @throws NullPointerException if value is null
     */
    private Optional(T value) {this.value = Objects.requireNonNull(value);}
	
	// 可以看出：Optional 仅允许我们以静态的方式构建
    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

	/**
     * @throws NullPointerException if value is null
     */
    public static <T> Optional<T> of(T value) {return new Optional<>(value);}

	// 该构造方式允许入参为null
    public static <T> Optional<T> ofNullable(T value) {return value == null ? empty() : of(value);}
	
	/********************** 如果是null的话,采取的下一步？ **********************/

    /**
     * @throws NullPointerException if value is present and {@code consumer} is null
     */
    public void ifPresent(Consumer<? super T> consumer) {if (value != null)consumer.accept(value);}

    /**
     * @throws NullPointerException if the predicate is null
     */
    public Optional<T> filter(Predicate<? super T> predicate) {...}

    /**
     * @throws NullPointerException if the mapping function is null
     */
    public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {...}

    /**
     * @throws NullPointerException if the mapping function is null or returns a null result
     */
    public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {...}

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

    /**
     * @throws NullPointerException if value is not present and {@code other} is null
     */
    public T orElseGet(Supplier<? extends T> other) {return value != null ? value : other.get();}

    /**
     * @throws X if there is no value present
     * @throws NullPointerException if no value is present and {@code exceptionSupplier} is null
     */
    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {...}

	/********************** 三个重写自java.lang.Object的方法 **********************/

    @Override
    public boolean equals(Object obj) {...}

    @Override
    public int hashCode() {return Objects.hashCode(value);}

    @Override
    public String toString() {return value != null ? String.format("Optional[%s]", value) : "Optional.empty";}
	
	/********************** 其他的一些不那么显眼的方法 **********************/
	
	// 判断null的方法
	public boolean isPresent() {return value != null;}
	
	/**
     * @throws NoSuchElementException if there is no value present
     */
    public T get() {...}
}

2. simple code

import com.google.common.collect.Lists;

import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.stream.Collectors;

/**
 * @Author: weng
 * @Date: 2022/5/8
 * @Description:
 *      怎么说呢？
 *      这个东西比较适合规范对象的构造吧
 *      要贯彻到整个项目中的话,需得要看个人习惯吧,毕竟代码不可能是一个人写完的吧
 *
 * @see java.util.Optional
 * @see java lambda 表达式的局部变量为什么必须是final修饰？
 */

public class TestOptional {

    private static List<Integer> out;

    public static void main(String[] args) {

        final List<Integer> in = Arrays.asList(1,-6,null,218,23,1,null,-33);

        // 我们需要做到：
        //  如果out不为null -> 每个不为null的元素做一次绝对值运算
        //  如果out为null -> 返回一个size=0的空集合

        dealProblem(in);

        Consumer c = list -> System.err.println(list);

        c.accept(obtainOut());
    }

    private final static void dealProblem(final List<Integer> in){

        Optional
                .ofNullable(in)
                .ifPresent(
                        inTmp -> {
                            // 编译器不允许lambda表达中对线程私有变量赋值
                            // 这虽然不会有安全问题
                            // 这是为了防止语义混乱的考虑
                            out = inTmp
                                    .stream()
                                    .filter(Objects::nonNull)
                                    .map(Math::abs)
                                    .collect(
                                            Collectors.toList()
                                    )
                            ;
                        }
                )
        ;
    }

    private final static List<Integer> obtainOut(){
        return Optional
                .ofNullable(out)
                .orElse(Lists.newArrayList())
        ;
    }

/*
    out >
        {"no":3,"name":"lorry"}
        {"no":3,"name":"lorry"}
    conclusion >
        引用类型的传递的是其实是地址
        实质是创建一个新的局部变量
        并指向作为参数传递到方法的地址

    public static void main(String[] args) {
        Person p = new Person(3,"lorry");
        System.out.println(p);
        testProp(p);
        System.err.println(p);
    }

    private static void testProp(Person p){
        p = Person.builder().name("beal").no(3).build();
    }
*/
}