Optional类学习总结

简单了解Optional类

---

众所周知,在日常开发中Null Pointer Exception 空指针异常是非常令人头疼的一件事情,为了避免这个问题我们不得不在代码中穿插大量的判空代码使得代码看起来非常的不优雅.而Java1.8的新特性Optional类就是用来解决这个痛点的,下面就来简单的了解一下Optional的使用吧.

   常规判断：
        //对象 人
        //属性有 name，age
        Person person=new Person();
       if (null==person){
            return "person为null";
        }
        return person;

     使用Optional：
        //对象 人
        //属性有 name，age
        Person person=new Person();
        return Optional.ofNullable(person).orElse("person为null");

测试展示类Person代码

public class Person {
    private String name;
    private Integer age;

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

Option类的使用

---

Optional对象创建

首先我们先打开Optional的源码把Optional对象的方法提取出来分析一下

public final class Optional<T> {
   private static final Optional<?> EMPTY = new Optional<>();
   private final T value;
   //我们可以看到两个构造方格都是private 私有的
   //说明 我们没办法在外面去new出来Optional对象
   private Optional() {
        this.value = null;
    }
   private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }
    //这个静态方法大致 是创建出一个包装值为空的一个对象因为没有任何参数赋值
   public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }
    //这个静态方法大致 是创建出一个包装值非空的一个对象 因为做了赋值
   public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }
    //这个静态方法大致是 如果参数value为空，则创建空对象，如果不为空，则创建有参对象
   public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }
 }

实例调用一下看看

// 1、创建一个包装对象值为空的Optional对象
Optional<String> optEmpty = Optional.empty();
// 2、创建包装对象值非空的Optional对象
Optional<String> optOf = Optional.of("optional");
// 3、创建包装对象值允许为空也可以不为空的Optional对象
Optional<String> optOfNullable1 = Optional.ofNullable(null);
Optional<String> optOfNullable2 = Optional.ofNullable("optional");

Optional.get()方法(返回对象的值)

源码如下:

//如果value不为空则做返回，如果为空则抛出异常 "No value present" 
public T get() {
    if (value == null) {
        throw new NoSuchElementException("No value present");
    }
    return value;
}

实例调用:

    public static void main(String[] args) {
        String hello = null;
        String world = Optional.ofNullable(hello).get();
    }
    //执行结果
    Exception in thread "main" java.util.NoSuchElementException: No value present
	at java.base/java.util.Optional.get(Optional.java:141)
	at Demo.main(Person.java:33)

Optional.isPresent()方法(判读是否为空)

源码:

// isPresent()方法就是会返回一个boolean类型值，如果对象不为空则为真，如果为空则false
 public boolean isPresent() {
        return value != null;
    }

实例调用:

    public static void main(String[] args) {
        String hello= null;
        if (Optional.ofNullable(hello).isPresent()){
            //写不为空的逻辑
            System.out.println("不为空");
        }else{
            //写为空的逻辑
            System.out.println("为空");
        }
    }
    //执行结果
    为空

Optional.ifPresent()方法(判读是否为空并返回函数)

源码:

//这个意思是如果对象非空，则运行函数体
public void ifPresent(Consumer<? super T> consumer) {
    //如果value不为空，则运行accept方法体
    if (value != null)
        consumer.accept(value);
}

实例调用:

public static void main(String[] args) {
    String hello = "world";
    Optional.ofNullable(hello).ifPresent(p -> System.out.println(hello));
}
//执行结果
world

Optional.filter()方法(过滤对象)

源码

// filter()方法大致意思是，接受一个对象，然后对他进行条件过滤，如果条件符合则返回Optional对象本身，如果不符合则返回空Optional 
public Optional<T> filter(Predicate<? super T> predicate) {
    Objects.requireNonNull(predicate);
    //如果为空直接返回this
    if (!isPresent())
        return this;
    else
    //判断返回本身还是空Optional
        return predicate.test(value) ? this : empty();
}

实例:

public static void main(String[] args) {
    String hello = "world";
    Optional<String> a = Optional.ofNullable(hello).filter(p -> "world".equals(p));
    Optional<String> b = Optional.ofNullable(hello).filter(p -> "hello world".equals(p));
    System.out.println("a:" + a);
    System.out.println("b:" + b);
}
//执行结果
a:Optional[world]
b:Optional.empty

Optional.map()方法(对象进行二次包装)

源码：

// map()方法将对应Funcation函数式接口中的对象，进行二次运算，封装成新的对象然后返回在Optional中
public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
    Objects.requireNonNull(mapper);
    //如果为空返回自己
    if (!isPresent())
        return empty();
    else {
    //否则返回用方法修饰过的Optional
        return Optional.ofNullable(mapper.apply(value));
    }
}

实例调用:

public static void main(String[] args) {
    String hello = null;
    String world = "world";
    String a = Optional.ofNullable(hello).map(p -> hello).orElse("hello为空");
    String b = Optional.ofNullable(world).map(p -> world).orElse("world为空");
    System.out.println("a:" + a);
    System.out.println("b:" + b);
}
//执行结果
a:hello为空
b:world

Optional.flatMap()方法(Optional对象进行二次包装)

源码:

// 同map(),但是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));
    }
}

实例调用:

public static void main(String[] args) {
    Person person = new Person();
    person.setSex("男");
    String aDefault = Optional.ofNullable(person).flatMap(p -> Optional.ofNullable(p.getSex())).orElse("default");
}

Optional.orElse()方法(为空返回对象)

源码:

// 这个方法意思是如果包装对象为空的话，就执行orElse方法里的value，如果非空，则返回写入对象
public T orElse(T other) {
    //如果非空，返回value，如果为空，返回other
    return value != null ? value : other;
}

实例调用:

public static void main(String[] args) {
    Person person=new Person();
    person.setSex("男");
    Optional.ofNullable(person).orElse(new Person("女"));
}

Optional.orElseGet()方法(为空返回Supplier对象)

源码:

// 这个与orElse很相似，入参不一样，入参为Supplier对象，为空返回传入对象的.get()方法，如果非空则返回当前对象
public T orElseGet(Supplier<? extends T> other) {
    return value != null ? value : other.get();
}

实例调用:

public static void main(String[] args) {
    Person person = new Person();
    Optional<Supplier<Person>> sup = Optional.ofNullable(Person::new);
    //调用get()方法，此时才会调用对象的构造方法，即获得到真正对象
    Person person1 = Optional.ofNullable(person).orElseGet(sup.get());
}

Optional.orElseThrow()方法(为空返回异常)

源码:

// 如果为空，就抛出你定义的异常，如果不为空返回当前对象
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
    if (value != null) {
        return value;
    } else {
        throw exceptionSupplier.get();
    }
}

实例调用:

public static void main(String[] args) throws Exception {
    Person person = null;
    try {
            Optional.ofNullable(person).orElseThrow(() -> new
                Exception("null"));
    } catch (Exception e) {
        System.out.println(e.getMessage());
    }
}

jdk1.9对Optional优化

首先增加了三个方法: or()、ifPresentOrElse() 和 stream()。 or() 与orElse等方法相似，如果对象不为空返回对象，如果为空则返回or()方法中预设的值。ifPresentOrElse() 方法有两个参数：一个 Consumer 和一个 Runnable。如果对象不为空，会执行 Consumer 的动作，否则运行 Runnable。相比ifPresent（）多了OrElse判断。stream()将Optional转换成stream，如果有值就返回包含值的stream，如果没值，就返回空的stream。