Java8 工具类Optional

Optional

package java.util;

// Java8自带封装工具类，主要用来空指针判断、避免空指针异常，目的是为了可以实现函函数式编程
public final class Optional<T> {
    private static final Optional<?> EMPTY = new Optional<>();
    private final T value;

    private Optional() {
        this.value = null;
    }
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

    public boolean isPresent() {
        return value != null;
    }
    public void ifPresent(Consumer<? super T> action) {
        if (value != null) {
            action.accept(value);
        }
    }
    public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
        if (value != null) {
            action.accept(value);
        } else {
            emptyAction.run();
        }
    }

    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent()) {
            return this;
        } else {
            return predicate.test(value) ? this : empty();
        }
    }

    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 <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent()) {
            return empty();
        } else {
            @SuppressWarnings("unchecked")
            Optional<U> r = (Optional<U>) mapper.apply(value);
            return Objects.requireNonNull(r);
        }
    }
    public T orElse(T other) {
        return value != null ? value : other;
    }
    // 没全部贴出...
}

本质来说，Optional就是把对象封装了一遍，增加了默认的判空设定避免程序空指针，实现了filter、map等，为了能像函数式编程一样实现链式编程。

/**
 * @author xuwejsnj
 * @date 2021/7/19
 */
public class OptionalTest {
    public static void main(String[] args) {
//        Customer user = null;
        Customer user = Customer.builder().name("xuw").age(23).addrInfo(
                AddrInfo.builder().addrCode("3010").addrStr("江苏省南京市").build()
            ).build();
        String addrCode1 = "default";
        if (user != null) {
            if (user.getAddrInfo() != null) {
                if (user.getAddrInfo().getAddrCode() != null) {
                    addrCode1 = user.getAddrInfo().getAddrCode();
                }
            }
        }

        String addrCode2 = Optional.ofNullable(user).map(Customer::getAddrInfo)
                .map(AddrInfo::getAddrCode).orElse("default");

        System.out.println(addrCode1);
        System.out.println(addrCode2);
    }
}
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
class Customer {
    private String name;
    private int age;
    private AddrInfo addrInfo;
}
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
class AddrInfo {
    private String addrCode;
    private String addrStr;
}

基本一眼看过去，喜欢哪种写法一目了然。其他的一些Optional方法，看源码都比较简单，这里就不在一一详细介绍了。

但是需要注意的是

• Optional没有实现序列号，最好不要用来定义类的属性。
• 请不要用Optional直接操作集合类，集合类还是建议用org.apache.commons.collections.CollectionUtils来判断（同理，数组、映射、Stream和Optional自身都不要用Optional再次包装）
• int、double、long用OptionalInt、OptionalDouble、OptionalLong，而不是直接用Optional包装封装类

本文技术菜鸟个人学习使用，如有不正欢迎指出修正。xuweijsnj