Java8的Optional、时间日期API

Supplier

Supplier在Java 8中被引入，属于java.util.function包。

    @FunctionalInterface
    public interface Supplier<T> {
        T get();
    }

Supplier的实例化方法主要有三种，通过Lambda表达式、通过方法引用、通过默认构造函数。Java还提供了用于特定数据类型的Supplier。

BooleanSupplier: Supplier返回Boolean数据类型。它的方法是getAsBoolean()。
IntSupplier: Supplier返回Integer数据类型。它的方法是getAsInt()。
LongSupplier: Supplier返回Long数据类型。它的方法是getAsLong()。
DoubleSupplier: Supplier返回Double数据类型。它的方法是getAsDouble()。

通过Lambda表达式实例化

	Supplier<String> s1 = () -> "Hello World!"; 

通过方法引用实例化

	//静态方法
	Supplier<String> s2 = MyUtils::getName;
    //非静态方法
    Supplier<String> s3 = myUtils::getName; 

通过默认构造函数实例化

 	Supplier<Random> s1 = Random::new; 
    Random random = s1.get();
    System.out.println(random.nextInt(10));

Consumer

    @FunctionalInterface
    public interface Consumer<T> {

        void accept(T t);

        default Consumer<T> andThen(Consumer<? super T> after) {
            Objects.requireNonNull(after);
            return (T t) -> { accept(t); after.accept(t); };
        }
    }

Function

    @FunctionalInterface
    public interface Function<T, R> {

        R apply(T t);

        default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
            Objects.requireNonNull(before);
            return (V v) -> apply(before.apply(v));
        }

        default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
            Objects.requireNonNull(after);
            return (T t) -> after.apply(apply(t));
        }

        static <T> Function<T, T> identity() {
            return t -> t;
        }
    }

Optional

Optional是一个容器对象，可以包含也可以不包含非null值。Optional在Java 8中引入，目的是解决  NullPointerExceptions的问题。本质上，Optional是一个包装器类，其中包含对其他对象的引用。在这种情况下，对象只是指向内存位置的指针，并且也可以指向任何内容。从其它角度看，Optional提供一种类型级解决方案来表示可选值而不是空引用。

在Optional出现之前，为了保证不出现空指针异常，需要对每个引用进行显式的空指针检查。

    private void getIsoCode(Person person){
        if (person != null) {
            Address address = person.getAddress();
            if (address != null) {
                Country country = address.getCountry();
                if (country != null) {
                    String province = country.getProvince();
                }
            }
        }
    }

Optional类

Optional类的构造函数是private，无法直接调用。Optional类内部维护一个value的对象。

    private static final Optional<?> EMPTY = new Optional<>();

 	/**
     * If non-null, the value; if null, indicates no value is present
     */
    private final T value;

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

Object类中的requireNonNull方法：

    public static <T> T requireNonNull(T obj) {
        if (obj == null)
            throw new NullPointerException();
        return obj;
    }

创建Optional类

empty()

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

of(T value)

通过of(T value)函数所构造出的Optional对象，当value值为空时，会报NullPointerException；当value值不为空时，能正常构造Optional对象。

    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

ofNullable(T value)

不论value是否为空，均可以能正常构造Optional对象。

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

Optional类的方法

get()

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

isPresent(), ifPresent()

isPresent()如果存在值，则返回true；反之，返回false。如果所包含的对象不为null，则返回true，反之返回false。通常在对对象执行任何其他操作之前，先在Optional上调用此方法。ifPresent()如果存在值，则使用该值调用指定的使用者；否则，什么都不做。

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

isPresent()和ifPresent()的使用：

	//原来的写法
    if (user != null){
       // TODO: do something
    }
    
    //现在的写法
    Optional.ofNullable(user).ifPresent(u->{
    // TODO: do something
	});

orElse(), orElseGet(), orElseThrow()

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