java8_Optional

Optional静态类简介，以及用法

很多的stream的终端操作，都返回了一个Optional对象，这个对象，是用来解决空指针的问题，而产生的一个类；

类定义：

import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

public final class Optional<T> {
	private static final Optional<?> EMPTY = new Optional<>();
	private final T value;
 
	private Optional() {
		this.value = null;
	}
 
	public static <T> Optional<T> empty() {
		@SuppressWarnings("unchecked")
		Optional<T> t = (Optional<T>) EMPTY;
		return t;
	}
 
private Optional(T value) {
	this.value = Objects.requireNonNull(value);
}
 
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> consumer) {
	if (value != null)
		consumer.accept(value);
}
 
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, Optional<U>> mapper) {
	Objects.requireNonNull(mapper);
	if (!isPresent())
		return empty();
	else {
		return Objects.requireNonNull(mapper.apply(value));
	}
}
 
public T orElse(T other) {
	return value != null ? value : 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 {
	if (value != null) {
		return value;
	} else {
		throw exceptionSupplier.get();
	}
}
 
@Override
public boolean equals(Object obj) {
	if (this == obj) {
		return true;
	}
 
	if (!(obj instanceof Optional)) {
		return false;
	}
 
	Optional<?> other = (Optional<?>) obj;
	return Objects.equals(value, other.value);
}
 
@Override
public int hashCode() {
	return Objects.hashCode(value);
}
 
@Override
public String toString() {
	return value != null ? String.format("Optional[%s]", value) : "Optional.empty";
}

构造方法被私有化，外部不能直接创建这个对象，静态方法中，也提供了实例化这个类的三个静态方法，

第一个是empty方法，直接返回一个类加载后就创建的一个空的optional对象，

第二个是of(T value)方法，可以看到，直接new了一个optional对象；

第三个是ofNullable(T value)方法，可以看到，这个方法，先对传入的泛型对象，做了null的判断，为null的话，返回第一个静态方法的空对象；

可以看到，有4种取泛型参数的方式；

1.get()直接取，如果为null，就返回异常

2.orElse(T other)在取这个对象的时候，设置一个默认对象（默认值）；如果当前对象为null的时候，就返回默认对象

3.orElseGet(Supplier<? extends T> other)跟第二个是一样的，区别只是参数，传入了一个函数式参数；

4. orElseThrow(Supplier<? extends X> exceptionSupplier)第四个，跟上面表达的是一样的，为null的时候，返回一个特定的异常；

isPresent()是对当前的value进行null判断

ifPresent(Consumer<? super T> consumer)具体的意思，可以参看《JAVA8 Consumer接口》，理解了consumer接口，也就理解了这个方法；

filter(Predicate<? super T> predicate)，map(Function<? super T, ? extends U> mapper) ，flatMap(Function<? super T, Optional> mapper) 这几个方法的应用，可以参看我的《JAVA8 Stream接口，map操作，filter操作，flatMap操作》，跟stream的上的方法，用法是一致的，没有区别；

案例，来演示

import java.util.Arrays;

public class Test {
public static void main(String[] args) {
	Arrays.asList("a", "b", "c");
	Emp emp = new Emp("xiaoMing", "上海", "11");
	Optional<Emp> op = Optional.ofNullable(emp);
	System.out.println(op.get().getAddress());// 上海
	Optional<Emp> op1 = Optional.ofNullable(null);
	System.out.println(op1.orElse(emp).getAddress());// 上海
	/*
	 * 这里指定了一个默认对象emp，为先创建的一个emp对象，emp对象里的成员变量还没有复制，所以输出为null
	 */
	System.out.println(op1.orElseGet(Emp::new).getAddress());
	try {
		System.out.println(op1.orElseThrow(RuntimeException::new));// java.lang.RuntimeException
 
	} catch (Exception e) {
		e.printStackTrace();
	}
	try {
		System.out.println(op1.get().getAddress());// java.util.NoSuchElementException
	} catch (Exception e) {
		e.printStackTrace();
	}
	String address = op.filter(obj -> obj.getAddress().equals("上海")).map(str -> str.getAddress()).get();
	System.out.println(address);// 上海
 
}
 
}