Optional<T>类是一个容器类，代表一个值存在或不存在，原来用null表示一个值不存在，现在Optional可以更好地表达这个概念。并且可以避免空指针异常。
-
Optional.of(T t)：创建一个Optional实例。对于该方法，传入的参数一定不能为
null，否则便会抛出NullPointerException。
private final T value;
private Optional(T value) {
this.value = Objects.requireNonNull(value);
}
public static <T> Optional<T> of(T value) {
return new Optional<>(value);
}
- Optional.empty()：创建一个空的Optional实例。即该 Optional 中不包含值。
private static final Optional<?> EMPTY = new Optional<>();
private Optional() {
this.value = null;
}
public static<T> Optional<T> empty() {
@SuppressWarnings("unchecked")
Optional<T> t = (Optional<T>) EMPTY;
return t;
}
-
Optional.ofNullable(T t)：若 t 不为null，创建Optional实例，否则创建空实例。该方法和 of 方法的区别在于，传入的参数可以为
null。因为该方法会判断传入的参数是否为 null，如果为 null 的话，返回的就是 Optional.empty()。
public static <T> Optional<T> ofNullable(T value) {
return value == null ? empty() : of(value);
}
- get()：获取 Optional 包含的值，如果值不存在，如在一个Optional.empty 上调用 get() 方法的话，将会抛出 NoSuchElementException 异常。
public T get() {
if (value == null) {
throw new NoSuchElementException("No value present");
}
return value;
}
- isPresent()：判断是否包含值。
- orElse(T t)：如果调用对象包含值，返回该值，否则返回 t 。
- orElseGet(Supplier s)：当 Optional 中有值的时候，返回值；当 Optional 中没有值的时候，返回从该 Supplier 获得的值。
- map(Function mapper)：如果有值对其处理，然后将返回的值包装在 Optional 中返回，否则返回Optional.empty()。
-
flatMap(Function mapper)：与map类似，区别在于，map 方法参数中的函数 mapper 输出的是值，然后 map 方法会使用
Optional.ofNullable将其包装为 Optional；而 flatMap 要求参数中的函数 mapper 输出的就是 Optional。 - filter(Predicate p)：filter 方法接受一个 Predicate 来对 Optional 中包含的值进行过滤，如果包含的值满足条件，那么还是返回这个 Optional；否则返回 Optional.empty。
【代码示例】
public class TestOptional {
@Test
public void test1(){
Optional<Employee> op = Optional.of(new Employee());
Employee e = op.get();
System.out.print(e);
}
@Test
public void test2(){
// 第一行（也就是op.get()之前）就会会产生NullPointException异常，能快速锁定传入的就是空值
Optional<Employee> op = Optional.of(null);
System.out.print(op.get());
// 构建一个空的Optional，不会产生异常
Optional<Employee> op1 = Optional.empty();
System.out.print(op1.get());
Optional<Employee> op2 = Optional.ofNullable(new Employee());
System.out.print(op2.get());
// op3.get() 会产生NullPointException异常
Optional<Employee> op3 = Optional.ofNullable(null);
System.out.print(op3.get());
}
@Test
public void test3(){
Optional<Employee> op = Optional.ofNullable(null);
// 判断是否包含值，如果包含则打印
/*if(op.isPresent()){
System.out.print(op.get());
}*/
// 如果op.get()是空那么就返回默认值，这样就不会产生空指针异常
Employee emp = op.orElse(new Employee("张三",18,888.9, Employee.Status.FREE));
System.out.print(emp);
}
@Test
public void test4(){
Optional<Employee> op = Optional.ofNullable(null);
// 函数式接口，可以写任何你想要的功能，而不仅仅是new Employee()
Employee emp = op.orElseGet(()->new Employee());
System.out.print(emp);
}
@Test
public void test5(){
Optional<Employee> op = Optional.ofNullable(new Employee("张三",18,888.9, Employee.Status.FREE));
Optional<String> str = op.map((e)->e.getName());
System.out.print(str.get()); //输出“张三”
}
@Test
public void test6(){
Optional<Employee> op = Optional.ofNullable(new Employee("张三",18,888.9, Employee.Status.FREE));
// flapMap要求返回值为 Optional<U>，进一步避免空指针的影响
Optional<String> str = op.flatMap((e) -> Optional.of(e.getName()));
System.out.print(str.get()); //输出“张三”
}
}
Optional的好处
public class Godness {
// 女神一定有名字，这样的值就可以不用封装到Optional中
private String name;
public Godness(String name) {
this.name = name;
}
public Godness() { }
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class Man {
private Godness godness;
public Man() { }
public Man(Godness godness) {
this.godness = godness;
}
public Godness getGodness() {
return godness;
}
public void setGodness(Godness godness) {
this.godness = godness;
}
}
public class NewMan {
/**
* 每个男人心中有可能有女神，有可能没有。Optional<>就是封装有可能有有可能没有的值
*
* 如果不给Optional对象赋值，那么默认这个Optional对象就是null，就没有意义了，
* 所以给Optional对象赋值为Optional.empty()，也就是一个空的Optional对象，而不是null
*/
private Optional<Godness> godness = Optional.empty();
public NewMan() {
}
public NewMan(Optional<Godness> godness) {
this.godness = godness;
}
public Optional<Godness> getGodness() {
return godness;
}
public void setGodness(Optional<Godness> godness) {
this.godness = godness;
}
}
public class TestMan {
@Test
public void test1(){
//产生空指针异常，这个男人没有女神
Man man = new Man();
String name = getGodnessName(man);
System.out.print(name);
Optional<NewMan> op = Optional.ofNullable(null);
String str = getGodnessName2(op); //不能直接传null，会产生NullPointException
System.out.print(str);
}
// 需求：获取一个男人心中女神的名字
public String getGodnessName(Man man){
if(man!=null){
Godness gn = man.getGodness();
if(gn!=null){
return gn.getName();
}
}
return "石原里美";
}
//传入参数也可能是空值，所以我们也可以用Optional进行封装
public String getGodnessName2(Optional<NewMan> man){
return man.orElse(new NewMan()) // 输入参数为空则new 一个男人
.getGodness()
.orElse(new Godness("石原里美")) //没有女神就返回一个默认的女神
.getName();
}
}
