从 Java 8 引入的一个很有趣的特性是 Optional 类。Optional 类主要解决的问题是臭名昭著的空指针异常（NullPointerException） —— 每个 Java 程序员都非常了解的异常。
本质上，这是一个包含有可选值的包装类，这意味着 Optional 类既可以含有对象也可以为空。
Optional 是 Java 实现函数式编程的强劲一步，并且帮助在范式中实现。但是 Optional 的意义显然不止于此。
我们从一个简单的用例开始。在 Java 8 之前，任何访问对象方法或属性的调用都可能导致 NullPointerException：
String province = user.getAddress().getCountry().toUpperCase();在这个小示例中，如果我们需要确保不触发异常，就得在访问每一个值之前对其进行明确地检查：
public interface UserDao{ User getUserById(String id); } public String getUsername(String id){ User user = getUserById(id); if (user != null) { String username = user.getUsername(); return username; } }使用 Optional 进行优化:
public interface UserDao{ User getUserById(String id); } public String getUsername(String id){ Optional<User> user = Optional.ofNullable(getUserById(id)); if (user.isPresent()) { String username = user.get().getUsername(); return username; } }好像看着代码是优美了点哟
—— 但是事实上这与之前判断 null 值的代码没有本质的区别，反而用 Optional 去封装 value，增加了代码量。所以我们来看看 Optional 还提供了哪些方法，让我们更好的（以正确的姿势）使用 Optional。
首先我们先上一张图，来简述一下Optional的使用时机
避免使用Optional.isPresent()来检查实例是否存在，因为这种方式和null != obj没有区别。
避免使用Optional.get()方式来获取实例对象，因为使用前需要使用Optional.isPresent()来检查实例是否存在，否则会出现NoSuchElementException异常问题。
尽量使用orElse()，orElseGet()，orElseThrow()获得结果
orElse(T other) 存在即返回，无则提供默认值
return user.orElse(null); //而不是 return user.isPresent() ? user.get() : null; return user.orElse(UNKNOWN_USER);这里要说明一下的是orElse(…)是急切计算，意味着类似下面代码：
Optional<Dog> optionalDog = fetchOptionalDog(); optionalDog .map(this::printUserAndReturnUser) .orElse(this::printVoidAndReturnUser)如果值存在则将执行两个方法，如果值不存在，则仅执行最后一个方法。为了处理这些情况，我们可以使用方法orElseGe()，它将supplier 作为参数，并且是惰性计算的。
orElseGet(Supplier<? extends T> other) 存在即返回, 无则由函数来产生
return user.orElseGet(() -> fetchAUserFromDatabase()); //而不要 return user.isPresent() ? user: fetchAUserFromDatabase();尽量使用ifPresent(Consumer<? super T> consumer)直接对数据进行操作
ifPresent() 存在才对它做点什么
user.ifPresent(System.out::println); //而不要下边那样 if (user.isPresent()) { System.out.println(user.get()); }避免使用Optional作为类或者实例的属性，而应该在返回值中用来包装返回实例对象。
避免使用Optional作为方法的参数。
不要将null赋给Optional。
只有当结果不确定时，使用Optional作为返回类型，从某种意义上讲，这是使用Optional的唯一好地方，用java官方的话讲就是：我们的目的是为库方法的返回类型提供一种有限的机制，其中需要一种明确的方式来表示“无结果”，并且对于这样的方法使用null 绝对可能导致错误。
不要害怕使用map和filter，有一些值得遵循的一般开发实践称为SLA-p：Single Layer of Abstraction字母的第一个大写。
下面是需要被重构代码到重构的代码
示例一
Dog dog = fetchSomeVaraible(); String dogString = dogToString(dog); public String dogToString(Dog dog){ if(dog == null){ return "DOG'd name is : " + dog.getName(); } else { return "CAT"; } } //上面代码重构到下面代码 Optional<Dog> dog = fetchDogIfExists(); String dogsName = dog .map(this::convertToDog) .orElseGet(this::convertToCat) public void convertToDog(Dog dog){ return "DOG'd name is : " + dog.getName(); } public void convertToCat(){ return "CAT"; }示例二
Dog dog = fetchDog(); if(optionalDog != null && optionalDog.isBigDog()){ doBlaBlaBla(optionalDog); } //上面代码重构到下面代码 Optional<Dog> optionalDog = fetchOptionalDog(); optionalDog .filter(Dog::isBigDog) .ifPresent(this::doBlaBlaBla)使所有表达式成为单行lambda。这是更普遍的规则，我认为也应该应用于流。但这篇文章是关于optional 。使用Optional 重要点是记住等式左边和右边一样重要。
这里举个例子
Optional .ofNullable(someVariable) .map(variable -> { try{ return someREpozitory.findById(variable.getIdOfOtherObject()); } catch (IOException e){ LOGGER.error(e); throw new RuntimeException(e); }}) .filter(variable -> { if(variable.getSomeField1() != null){ return true; } else if(variable.getSomeField2() != null){ return false; } else { return true; } }) .map((variable -> { try{ return jsonMapper.toJson(variable); } catch (IOException e){ LOGGER.error(e); throw new RuntimeException(e); }})) .map(String::trim) .orElseThrow(() -> new RuntimeException("something went horribly wrong."))上面那么冗长代码块可以使用方法替代：
Optional .ofNullable(someVariable) .map(this::findOtherObject) .filter(this::isThisOtherObjectStale) .map(this::convertToJson) .map(String::trim) .orElseThrow(() -> new RuntimeException("something went horribly wrong."));Optional 的三种构造方式：Optional.of(T value)， Optional.ofNullable(T value) 和明确的 Optional.empty()。
该方法通过一个非 null 的 value 来构造一个 Optional，返回的 Optional 包含了 value 这个值。对于该方法，传入的参数一定不能为 null，否则便会抛出 NullPointerException。。
该方法以一种智能的，宽容的方式来构造一个 Optional 实例。来者不拒，传 null 值就得到 Optional.empty()，非 null 值就调用 Optional.of(T value)。
该方法用来构造一个空的 Optional，即该 Optional 中不包含值。
源码
public boolean isPresent() { return value != null; }如果 Optional 中值存在返回 true，否则返回 false。不经常使用。
示例代码
Optional<User> user = Optional.ofNullable(getUserById(id)); if(user.isPresent()){ System.out.println("Username is: " + user.get().getUsername()); }else { System.out.println("Username is unknow!"); }源码
public void ifPresent(Consumer<? super T> consumer) { if (value != null) consumer.accept(value); }如果 Optional 中有值，则对该值调用 consumer.accept，否则什么也不做。
示例代码
Optional<User> user = Optional.ofNullable(getUserById(id)); user.ifPresent(u -> System.out.println("Username is: " + u.getUsername()));源码
public T get() { if (value == null) { throw new NoSuchElementException("No value present"); } return value; }如果Optional有值则将其返回，否则抛出NoSuchElementException。不经常使用。
示例
Optional<User> user = Optional.ofNullable(getUserById(id)); if(user.isPresent()){ System.out.println("Username is: " + user.get().getUsername()); }else { System.out.println("Username is unknow!"); }源码
public T orElse(T other) { return value != null ? value : other; }如果 Optional 中有值则将其返回，否则返回 orElse 方法传入的参数。
示例
User user = Optional .ofNullable(getUserById(id)) .orElse(new User(0, "Unknown")); System.out.println("Username is: " + user.getUsername());源码
public T orElseGet(Supplier<? extends T> other) { return value != null ? value : other.get(); }orElseGet 与 orElse 方法的区别在于，orElseGet 方法传入的参数为一个 Supplier 接口的实现 —— 当 Optional 中有值的时候，返回值；当 Optional 中没有值的时候，返回从该 Supplier 获得的值。
示例
User user = Optional .ofNullable(getUserById(id)) .orElseGet(() -> new User(0, "Unknown")); System.out.println("Username is: " + user.getUsername());源码
public T orElseGet(Supplier<? extends T> other) { return value != null ? value : other.get(); }orElseThrow与 orElse 方法的区别在于，orElseThrow方法当 Optional 中有值的时候，返回值；没有值的时候会抛出异常，抛出的异常由传入的 exceptionSupplier 提供。
示例
User user = Optional .ofNullable(getUserById(id)) .orElseThrow(() -> new EntityNotFoundException("id 为 " + id + " 的用户没有找到"));举一个 orElseThrow 的用途：在 SpringMVC 的控制器中，我们可以配置统一处理各种异常。查询某个实体时，如果数据库中有对应的记录便返回该记录，否则就可以抛出 EntityNotFoundException ，处理 EntityNotFoundException 的方法中我们就给客户端返回Http 状态码 404 和异常对应的信息 —— orElseThrow 完美的适用于这种场景。
@RequestMapping("/{id}") public SysUser getSysUser(@PathVariable Integer id) { Optional<SysUser> user = userService.getSysUserById(id); return user.orElseThrow(() -> new EntityNotFoundException("id 为 " + id + " 的用户不存在")); } @ExceptionHandler(EntityNotFoundException.class) public ResponseEntity<String> handleException(EntityNotFoundException ex) { return new ResponseEntity<>(ex.getMessage(), HttpStatus.NOT_FOUND); }源码
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 为 Optional.empty，则依旧返回 Optional.empty；否则返回一个新的 Optional，该 Optional 包含的是：函数 mapper 在以 value 作为输入时的输出值。
示例
Optional<String> username = Optional .ofNullable(getUserById(id)) .map(user -> user.getUsername()); System.out.println("Username is: " + username.orElse("Unknown")); //我们可以多次使用map操作 Optional<String> username = Optional .ofNullable(getUserById(id)) .map(user -> user.getUsername()) .map(name -> name.toLowerCase()) .map(name -> name.replace('_', ' ')); System.out.println("Username is: " + username.orElse("Unknown"));源码
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)); } }flatMap 方法与 map 方法的区别在于：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"));源码
public Optional<T> filter(Predicate<? super T> predicate) { Objects.requireNonNull(predicate); if (!isPresent()) return this; else return predicate.test(value) ? this : empty(); }filter 方法接受一个 Predicate 来对 Optional 中包含的值进行过滤，如果包含的值满足条件，那么还是返回这个 Optional；否则返回 Optional.empty。
示例
Optional<String> username = Optional .ofNullable(getUserById(id)) .filter(user -> user.getId() < 10) .map(user -> user.getUsername()); System.out.println("Username is: " + username.orElse("Unknown"));