java8的Optional 详解

<>1、Optional 介绍

传统的写代码方式经常会遇到NullPointerException，这就需要我们在代码中经常判空。而判空的写法又会显得很累赘，这里就可以用到Optional来简化代码。

Optional是在java.util包下的一个用于代替null的一个工具类。
import java.util.Optional;
* Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。
* Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
* Optional 类的引入很好的解决空指针异常。
<>2、构建Optional

构建一个Optional对象；方法有：empty( )、of( )、ofNullable( )
//返回一个描述给定值的Optional ，如果不为null ，则返回一个空的Optional 。 //参数：值–描述的可能为null值
//类型参数：<T> –值的类型 //返回值：一个Optional与如果指定值是非当前值null ，否则一个空Optional Optional.
ofNullable(T value);//value为null的话返回-Optional.empty()；
//返回一个Optional描述给定的非null值。 //参数：value –要描述的值，必须为非null //类型参数：<T> –值的类型
//返回值：存在值的Optional Optional.of(T value);// value需要非 null,null会抛异常；
//返回一个空的Optional实例。 此Optional没有值。 //类型参数：<T> –不存在的值的类型 //返回值：一个空的Optional
//api注意：尽管这样做可能很诱人，但应通过将==与Optional.empty()返回的实例进行比较来避免测试对象是否为空。 // 不能保证它是一个单例。
// 而是使用isPresent() Optional.empty();// 用来构造一个空的 Optional；
<>3、Optional的相关方法介绍

* isPresent()： 持有非空值，返回true；否则false； Optional optional = Optional.ofNullable(
null); Optional optional1 = Optional.of(""); Optional optional2 = Optional.empty
(); System.out.println(optional.isPresent()); System.out.println(optional1.
isPresent()); System.out.println(optional2.isPresent());
打印结果：
false true false
* ifPresent()： 如果 Optional 中有值，则对该值调用consumer.accept，否则什么也不做。
* orElse： 参数是一个值，如果 Optional 中有值则将其返回，否则返回 orElse 方法传入的参数。
Optional 中有值：
//Optional 中有值 Optional optional = Optional.ofNullable("fdgshsgf"); System.out.
println(optional.orElse("reiwgybv"));
打印结果：

Optional 中没有值：
//Optional 中有没有值 Optional optional = Optional.ofNullable(null); System.out.
println(optional.orElse("reiwgybv"));
打印结果：

注意：
Optional 只有null时表示为空值，其他任何情况都不表示空值，如空字符串。
Optional optional = Optional.ofNullable(""); System.out.println(optional.orElse
("reiwgybv"));
打印结果是空字符串：

* orElseGet： 传入的参数为一个 Supplier 接口的实现。
* orElseThrow： 没有值的时候会抛出异常，抛出的异常由传入的 exceptionSupplier 提供。
示例：
return Optional.ofNullable(iNewsMapper.selectNewsWithNewsCategoryById(id)) .
orElseThrow(() -> new BaseException(DataSourceResponseEnum.SELECT_ERROR));
* map： 为空返回 Optional.empty；否则返回一个新的 Optional：函数 mapper 在以 value
作为输入时的输出值；可以多次使用map操作。 Optional<String> username = Optional.ofNullable(
getUserById(id)) .map(user -> user.getUsername()) .map(name -> name.replace('_',
' ')); System.out.println("Username is: " + username.orElse("Unknown"));
* flatMap： map 方法参数中的函数 mapper 输出的是值，然后 map 方法会使用 Optional.ofNullable 将其包装为
Optional；而 flatMap 要求参数中的函数 mapper 输出的就是 Optional。 Optional<String> username =
Optional.ofNullable(getUserById(id)) .flatMap(user -> Optional.of(user.
getUsername())) .flatMap(name -> Optional.of(name.toLowerCase())); System.out.
println("Username is: " + username.orElse("Unknown"));
* filter： 接受一个 Predicate 来对 Optional 中包含的值进行过滤，如果包含的值满足条件，那么还是返回这个
Optional；否则返回 Optional.empty。
<>4、源码解析
package java.util; import java.util.function.Consumer; import java.util.
function.Function; import java.util.function.Predicate; import java.util.
function.Supplier; import java.util.stream.Stream; /** 一个可能包含也可能不包含非null值的容器对象。
如果存在值，则isPresent()返回true 。 如果不存在任何值，则该对象被视为空，并且isPresent()返回false 。
提供了其他取决于所包含值是否存在的方法，例如orElse() （如果不存在值，则返回默认值）和ifPresent() （如果存在值，则执行操作）。
这是一个基于值的类； 在Optional实例上使用标识敏感的操作（包括引用等于（ == ），标识哈希码或同步）可能会产生不可预测的结果，应避免使用 */
public final class Optional<T> { /** * empty()通用实例 */ private static final
Optional<?> EMPTY = new Optional<>(); /** * 如果不为空，则为该值；否则为false。
如果为null，则表示不存在任何值 */ private final T value; /** 构造一个空实例。 impl注意：
通常，每个VM仅应存在一个空实例EMPTY */ private Optional() { this.value = null; } /**
返回一个空的Optional实例。 此Optional没有值。 类型参数：<T> –不存在的值的类型 返回值：一个空的Optional api注意：
尽管这样做可能很诱人，但应通过将==与Optional.empty()返回的实例进行比较来避免测试对象是否为空。 不能保证它是一个单例。
而是使用isPresent() */ public static<T> Optional<T> empty() { @SuppressWarnings(
"unchecked") Optional<T> t = (Optional<T>) EMPTY; return t; } /** 使用描述的值构造一个实例。
参数：值–要描述的非null值 抛出：NullPointerException如果值为null */ private Optional(T value) {
this.value = Objects.requireNonNull(value); } /** 返回一个Optional描述给定的非null值。
参数：value –要描述的值，必须为非null 类型参数：<T> –值的类型 返回值：存在值的Optiona */ public static <T>
Optional<T> of(T value) { return new Optional<>(value); } /**
返回一个描述给定值的Optional ，如果不为null ，则返回一个空的Optional 。 参数：值–描述的可能为null值 类型参数：<T> –值的类型
返回值：一个Optional与如果指定值是非当前值null ，否则一个空Optional */ public static <T> Optional<T>
ofNullable(T value) { return value == null ? empty() : of(value); } /**
如果存在值，则返回该值，否则抛出NoSuchElementException 。 返回值：此Optional描述的非null值
抛出：NoSuchElementException如果不存在任何值 api注意：此方法的首选替代方法是orElseThrow() 。 */ public T
get() { if (value == null) { throw new NoSuchElementException("No value present"
); } return value; } /** 如果存在值，则返回true ，否则返回false 。 返回值：如果存在值，则为true ，否则为false
*/ public boolean isPresent() { return value != null; } /** 如果不存在值，则返回true
，否则返回false 。 返回值：如果不存在值，则为true ，否则为false */ public boolean isEmpty() { return
value== null; } /** 如果存在值，则使用该值执行给定的操作，否则不执行任何操作。 参数：动作–要执行的动作（如果存在值） */ public
void ifPresent(Consumer<? super T> action) { if (value != null) { action.accept(
value); } } /** 如果存在值，则使用该值执行给定的操作，否则执行给定的基于空的操作。
参数：动作–要执行的动作（如果存在值）emptyAction –要执行的基于空的操作（如果不存在任何值）
抛出：NullPointerException如果存在一个值并且给定的操作为null ，或者不存在任何值并且给定的基于空的操作为null @since 9 */
public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
if (value != null) { action.accept(value); } else { emptyAction.run(); } } /**
如果存在一个值，并且该值与给定的谓词匹配，则返回描述该值的Optional ，否则返回一个空的Optional 。 参数：谓词–应用于值的谓词（如果存在）
返回值：一个Optional描述此的值Optional ，如果一个值存在并且该值给定的谓词相匹配，否则一个空Optional
抛出：NullPointerException如果谓词为null */ public Optional<T> filter(Predicate<? super
T> predicate) { Objects.requireNonNull(predicate); if (!isPresent()) { return
this; } else { return predicate.test(value) ? this : empty(); } } /**
如果存在值，则返回一个Optional描述（就像by ofNullable ），将给定映射函数应用于该值的结果，否则返回一个空的Optional 。
如果映射函数返回null结果，则此方法返回空的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 -bearing映射函数应用于该值的结果，否则返回一个空的Optional 。
此方法类似于map(Function) ，但是映射函数是其结果已经是Optional函数，如果调用该函数，则flatMap不会将其包装在其他Optional
。 参数：mapper –应用于值的映射函数（如果存在） 类型参数：<U> –映射函数返回的Optional值的类型
返回值：施加的结果Optional荷瘤映射函数此的值Optional ，如果一个值存在，否则一个空Optional
抛出：NullPointerException如果映射函数为null或返回null结果 */ 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); } } /**
如果值存在时，返回一个Optional描述的值，否则将返回一个Optional产生通过供给功能。 参数：供应商–产生要返回的Optional的供应功能
返回值：返回一个Optional描述此的值Optional ，如果一个值存在，否则Optional所生产的供应功能。
抛出：NullPointerException如果提供的函数为null或产生null结果 * @since 9 */ public Optional<T> or
(Supplier<? extends Optional<? extends T>> supplier) { Objects.requireNonNull(
supplier); if (isPresent()) { return this; } else { @SuppressWarnings(
"unchecked") Optional<T> r = (Optional<T>) supplier.get(); return Objects.
requireNonNull(r); } } /** 如果存在值，则返回仅包含该值的顺序Stream ，否则返回空Stream 。
返回值：作为Stream的可选值 * @since 9 */ public Stream<T> stream() { if (!isPresent()) {
return Stream.empty(); } else { return Stream.of(value); } } /**
如果存在值，则返回该值，否则返回other 。 参数：其他–要返回的值（如果不存在任何值）。 可以为null 。 返回值：值（如果存在），否则other */
public T orElse(T other) { return value != null ? value : other; } /**
如果存在值，则返回该值，否则返回由供应函数产生的结果。 参数：供应商–产生要返回的值的供应函数 返回值：值（如果存在），否则提供功能产生的结果 */
public T orElseGet(Supplier<? extends T> supplier) { return value != null ?
value: supplier.get(); } /** * If a value is present, returns the value,
otherwise throws * {@code NoSuchElementException}. * * @return the non-{@code
null} value described by this {@code Optional} * @throws NoSuchElementException
if no value is present * @since 10 */ public T orElseThrow() { if (value == null
) { throw new NoSuchElementException("No value present"); } return value; } /**
如果存在值，则返回该值，否则抛出由异常提供函数产生的异常。 参数：exceptionSupplier –产生要抛出的异常的提供函数 类型参数：<X>
–引发的异常类型 返回值：值（如果存在） 抛出：X –如果不存在任何值NullPointerException如果不存在任何值并且异常提供函数为null
api注意：带有空参数列表的对异常构造函数的方法引用可用作提供者 */ public <X extends Throwable> T orElseThrow(
Supplier<? extends X> exceptionSupplier) throws X { if (value != null) { return
value; } else { throw exceptionSupplier.get(); } } }
<>5、结合业务现实解析

创建一个动物实体类：
/** * 动物实体类 */ @Data public class Animal { private String lb;//类别 private
String name;//姓名 private Integer age; //年龄 }
<>（1）Optional 构建
//返回一个描述给定值的Optional ，如果不为null ，则返回一个空的Optional 。 //参数：值–描述的可能为null值
//类型参数：<T> –值的类型 //返回值：一个Optional与如果指定值是非当前值null ，否则一个空Optional Optional s1 =
Optional.ofNullable(null); //
构建一个value不可以为null的optional对象，如果of()的入参为null会报空指针异常； Optional<Animal> s2 =
Optional.of(new Animal("哺乳动物", "小狗",5)); // 构建一个value可以为null的optional对象；
Optional<Animal> s3 = Optional.ofNullable(null); System.out.println(s1); System.
out.println(s2); System.out.println(s3);
输出结果：

<>（2）判断类业务
Optional<Animal> myUser1 = Optional.empty(); Optional<Animal> myUser2 =
Optional.of(new Animal("哺乳动物", "小猫",8)); //
filter传入一个lambda，lambda返回值为boolean；true:不做任何改变，false:返回一个空的optional； Optional<
Animal> myUser3 = myUser2.filter(animal -> "小猫".equals(animal.getName()));
Optional<Animal> myUser4 = myUser2.filter(animal -> "小7猫".equals(animal.getName(
))); //
isPresent就是判断value是不是null；我们在调用get之前，一定要先调用isPresent，因为直接如果value是null，直接调用get会报异常；
if (myUser1.isPresent()) { Animal value = myUser1.get(); System.out.println(
"optional value:" + value); } else { System.out.println("optional value==null");
} // ifPresent传入一段lambda，当value!=null时，执行里面的逻辑；当当value==null时，啥都不干； myUser2.
ifPresent(value -> System.out.println("optional value:" + value)); System.out.
println(myUser3); System.out.println(myUser4);
输出结果：

<>（3）获取类业务（常用）
Optional<Animal> userInfoEmptyOpt = Optional.empty(); Optional<Animal>
userInfoOpt= Optional.of(new Animal("猫科动物","哆啦A梦",15)); //
1、直接获取，注意如果value==null，会报NoSuchElementException异常 Animal userInfo1 = userInfoOpt
.get(); // 2、orElse可以传入一个UserInfo类型的对象作为默认值; //
当value!=null时，返回value值；当value==null时，返回默认值作为代替； Animal userInfo2 =
userInfoEmptyOpt.orElse(new Animal("猫科动物1","哆啦A梦",15)); //
3、orElseGet和orElse不同的是orElseGet可以传入一段lambda表达式； // 当value!=null时，返回value值； //
当value==null时，使用该lambda返回的对象作为默认值； Animal userInfo3 = userInfoEmptyOpt.orElseGet
(() -> new Animal("猫科动物2","哆啦A梦",15)); //
4、orElseThrow可以传入一段lambda表达式，lambda返回一个Exception；当value!=null时，返回value值；当value==null时，抛出该异常；
Animal userInfo4 = userInfoOpt.orElseThrow(NullPointerException::new); System.
out.println(userInfo1); System.out.println(userInfo2); System.out.println(
userInfo3); System.out.println(userInfo4);
输出结果：

<>（4）转换类业务
Optional<Animal> userInfoOpt = Optional.of(new Animal("犬科动物","史努比",10)); //
原来value的类型是UserInfo，经过map转换为Optional<String> Optional<String> username =
userInfoOpt.map(Animal::getLb); //
当map的入参也是一个Optional时，经过map转化后会形成Optional<Optional<String>>这种嵌套结构；但flatMap可以把这种嵌套结构打平；
Optional<Optional<String>> unFlatMap = userInfoOpt.map(animal -> Optional.of(
animal.getLb())); Optional<String> flatMap = userInfoOpt.flatMap(animal ->
Optional.of(animal.getLb())); System.out.println(username); System.out.println(
unFlatMap); System.out.println(flatMap);
输出结果：

<>6、项目业务API测试
import lombok.AllArgsConstructor; import lombok.Data; import lombok.
NoArgsConstructor; import lombok.ToString; import java.math.BigDecimal; @Data
@NoArgsConstructor @AllArgsConstructor @ToString public class Leader { private
Long employeeId; private BigDecimal bonus; } import lombok.AllArgsConstructor;
import lombok.Data; import lombok.NoArgsConstructor; import lombok.ToString;
@Data @NoArgsConstructor @AllArgsConstructor @ToString public class Employee {
private Long id; private String name; private Boolean leader; } import java.util
.Optional; /** * 找到ID为1的员工，如果有奖金就打印出来，没有就打印没有奖金； * @throws */ public class
FiltUtil { public void OptionalStudy() { Optional<Leader> leader = Optional.
ofNullable(getEmployeeById(1L) .filter(Employee::getLeader) .map(Employee::getId
) .flatMap(this::getLeaderByEmployeeId) .orElse(null)); if (leader.isPresent())
{ Optional.of(leader.map(Leader::getBonus).map(bonus -> String.format(
"员工ID为1的leader奖金为：%s", bonus)).orElse("员工ID为1的leader也没有奖金")).ifPresent(System.
out::println); } else { System.out.println("员工ID为1的leader未找到，他可能只是一个基层员工，不配拥有奖金"
); } } private Optional<Employee> getEmployeeById(Long id) { //return
Optional.of(new Employee(1L, "大老板", Boolean.TRUE)); return Optional.of(new
Employee(1L, "大老板", Boolean.FALSE)); } private Optional<Leader>
getLeaderByEmployeeId(Long employeeId) { //return employeeId == 1L ?
Optional.of(new Leader(1L, BigDecimal.valueOf(1000000000))) : Optional.empty();
return employeeId == 1L ? Optional.of(new Leader(1L, null)) : Optional.empty();
} //主函数测试 public static void main(String[] args) { FiltUtil filtUtil = new
FiltUtil(); filtUtil.OptionalStudy(); } }

• « 上一篇：【Android安全】IDA 处理伪代码JUMPOUT指令（Undefine + Create Function）
• » 下一篇：Python 学生信息管理系统------文章中源码100%真实有效-----如何将类、初始化属性、模块、循环判断、静态方法等一系列知识点结合起来做一个项目