在任何语言开发中我们都会遇到很多bug，然后在众多bug中，空指针又是出现最多的，每个编程语言都有空指针，只不过有些语言对空指针有了系统处理，例如 kotlin会自动检测空指针的存在并在编写代码的时候就报错，java没有这功能，但是在java8之后 有一个类可以为我们解决空指针的问题，它就是Optional
我们看源码里面的一段话，就知道optional想干嘛了
A object which may or may not contain a non-null value.
可以理解optional是一个容器，它在里面帮我们做了非空判断
接下来我们从源码的角度分析Optional里面的具体功能
1、empty
源码分析：
public static<T> Optional<T> empty() {
@SuppressWarnings("unchecked")
Optional<T> t = (Optional<T>) EMPTY;
return t;
}
/**
创建一个空的Optional，也就是里面什么都没有 只是一个空的容器
*/
用法：
Optional<String> emptyOptional = Optional.empty();
System.out.println(emptyOptional.get());//报错
System.out.println(emptyOptional.orElse("unkonwn"));//打印unkonwn
//既然是空的里面就没有数据，就不可能拿到数据
2、ofNullable
源码分析：
从源码主注释里面来看，这是在创建一个非空的Optional容器，如果你传入空值，他就会创建一个空的容器，从下面的三目运算符可以看出，如果不是空值，就会调用of方法，of的方法往下翻
/**
* Returns an {@code Optional} describing the specified value, if non-null,
* otherwise returns an empty {@code Optional}.
*
* @param <T> the class of the value
* @param value the possibly-null value to describe
* @return an {@code Optional} with a present value if the specified value
* is non-null, otherwise an empty {@code Optional}
*/
public static <T> Optional<T> ofNullable(T value) {
return value == null ? empty() : of(value);
}
用法
Optional<String> optional1 = Optional.ofNullable(null);
Optional<String> optional2 = Optional.ofNullable("hb");
System.out.println(optional1); //空值不能调用get 返回Optional.empty
System.out.println(optional2.get()); //打印hb
3、of
源码分析：
从源码里面看，这里创建的是一个有内容的容器 Optional，注意不要传空值，注释里面说了，传空值会报错的，所以我们再创建的时候还是调用ofNullable这个来创建，你传入空值它就创建空的容器，不是空它就调用of
/**
* Returns an {@code Optional} with the specified present non-null value.
*
* @param <T> the class of the value
* @param value the value to be present, which must be non-null
* @return an {@code Optional} with the value present
* @throws NullPointerException if value is null
*/
public static <T> Optional<T> of(T value) {
return new Optional<>(value);
}
4、get
源码分析：
get其实就是返回里面的值，只不过在源码里面帮你做了判断
/**
* If a value is present in this {@code Optional}, returns the value,
* otherwise throws {@code NoSuchElementException}.
*
* @return the non-null value held by this {@code Optional}
* @throws NoSuchElementException if there is no value present
*
* @see Optional#isPresent()
*/
public T get() {
if (value == null) {
throw new NoSuchElementException("No value present");
}
return value;
}
用法就不多说了，上面有例子，直接调用就行 返回值
5、orElse
源码分析：
从源码里面来看，这个方法传入一个值，如果容器中有值就返回值，如果没有值则返回我们这里传入的值，这里传入的值一般是提示 如 -1
/**
* Return the value if present, otherwise return {@code other}.
*
* @param other the value to be returned if there is no value present, may
* be null
* @return the value, if present, otherwise {@code other}
*/
public T orElse(T other) {
return value != null ? value : other;
}
用法：
Optional<String> optional1 = Optional.ofNullable(null);
Optional<String> optional2 = Optional.ofNullable("hb");
System.out.println(optional1.orElse("里面是空的")); //打印 里面是空的
System.out.println(optional2.get()); //打印hb
6、orElseGet
源码分析：
首先如果值不为空的话和get一样返回值，如果为空就会使用函数式接口，返回函数式接口里面的内容，
如果不懂什么是函数式接口请看我前面的文章，
Supplier 不用传参，返回一个T对象， T表示泛型
/**
* Return the value if present, otherwise invoke {@code other} and return
* the result of that invocation.
*
* @param other a {@code Supplier} whose result is returned if no value
* is present
* @return the value if present otherwise the result of {@code other.get()}
* @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();
}
用法：
肯定有人感觉
Optional<String> optional1 = Optional.ofNullable(null);
Optional<String> optional2 = Optional.ofNullable("hb");
System.out.println(optional1.orElse("没有内容")); //打印 里面是空的
System.out.println(optional2.get()); //打印hb
System.out.println(optional1.orElseGet(()->"数据为空")); //打印 hb
System.out.println(optional2.orElseGet(()->"数据为空")); //打印 数据为空
7、orElseThrow
源码分析
从源码的角度分析我们知道，当Optional中有值的话，就返回该值，没有值的话就抛出一个异常，这个异常是有Supplier函数式接口提供的
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
if (value != null) {
return value;
} else {
throw exceptionSupplier.get();
}
}
用法:
Optional<String> stringOptional = Optional.of("hb");
System.out.println(stringOptional.orElseThrow(CustomException::new));
Optional<String> emptyOptional = Optional.empty();
System.out.println(emptyOptional.orElseThrow(CustomException::new));
private static class CustomException extends RuntimeException {
private static final long serialVersionUID = -4399699891687593264L;
public CustomException() {
super("exception");
}
public CustomException(String message) {
super(message);
}
}
8、filter
源码分析：
在这里我们知道filter这个方法传入一个Predicate的函数式接口，过滤元素，将符合条件的元素重新生成一个Optional对象，否则将会生成一个空的Optional对象
这里的Predicate函数式接口我在前面的文章有详细的介绍
/**
* If a value is present, and the value matches the given predicate,
* return an {@code Optional} describing the value, otherwise return an
* empty {@code Optional}.
*
* @param predicate a predicate to apply to the value, if present
* @return an {@code Optional} describing the value of this {@code Optional}
* if a value is present and the value matches the given predicate,
* otherwise an empty {@code Optional}
* @throws NullPointerException if the predicate is null
*/
public Optional<T> filter(Predicate<? super T> predicate) {
Objects.requireNonNull(predicate);
if (!isPresent())
return this;
else
return predicate.test(value) ? this : empty();
}
用法:
Optional<String> optionalList = Optional.ofNullable("xioaming");
System.out.println(optionalList.filter(it->it.length()>5).get()); //打印小明
System.out.println(optionalList.filter(it->it.length()>10).get()); //异常
9 map
源码分析
map这个方法是利用Function进行操作，当其中包含元素，不为空，将元素输入Function函数式接口中，输入一个元素形成另一个并返回，返回类型可以不是Optional类型，源码里可以看到并没有做封装，如果Optional元素为空就会调用empty创建一个空的Optional
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));
}
}
用法:
Optional<String> stringOptional = Optional.of("xiaoming");
System.out.println(stringOptional.map(e -> e.toUpperCase()).orElse("fail"));
//这里是将字符串全部转换成大写，如果不存在则会调用后面的orElse
10、flagMap
源码分析：
从flagMap的源码里面看到，我们再调用flatMap的时候 返回的类型必须是Optional这个类型，也就是在返回的随时候给我们做了封装
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));
}
}
用法:
Optional<String> stringOptional = Optional.of("xiaoming");
System.out.println(stringOptional.flatMap(e -> Optional.of("haha")).orElse("失败"));
//打印出来的是 haha
11、ifPresent
源码分析
这个方法可能是我们以后用的比较多的方法，它在源码里面的解释知道，它表示在Optional里面的值不为空的情况下使用Consumer函数式接口去消费，也就是我们自己想做什么事，如果为空就什么也不做，肯定不会报错，很好的避免了空指针
/**
* If a value is present, invoke the specified consumer with the value,
* otherwise do nothing.
*
* @param consumer block to be executed if a value is present
* @throws NullPointerException if value is present and {@code consumer} is
* null
*/
public void ifPresent(Consumer<? super T> consumer) {
if (value != null)
consumer.accept(value);
}