04-Optional类和接口中的default、static方法

若想了解java8其它新特性，请到 00-java8常用新特性文章索引阅读。

这篇文章，介绍Java8的 Optional 类和接口的 default、static 方法。

1、Optional类

Optional：Java8 java.util包中提供的一个可以包含或者不包含非null值的容器对象。
通过 Optional 我们不用显式进行空值检测 ( if( T == null ) )也很好的解决空指针异常

1.1 Optional API

Optional 方法	说明
static Optional empty()	返回一个空Optional(值为null)
boolean equals(Object obj)	指示给定的对象是否 equals 此Optional的value
Optional filter(Predicate	如果 Optional 的值存在而且匹配给定的 predicate（断定型函数式接口），返回当前Optional，否则返回一个空Optional(值为null)
Optional flatMap(Function> mapper)	如果 Optional 的值存在,应用提供的映射方法并返回结果 Optional，否则返回一个空的Optional
T get()	如果此 Optional 存在值，则返回值，否则抛出NoSuchElementException
int hashCode()	返回当前值的哈希码值（如果有），如果没有值，则返回0。
void ifPresent(Consumer consumer)	如果存在值，对该值应用指定的 Consumer（消费型函数式接口），否则不执行任何操作。
boolean isPresent()	如果存在值，返回true，否则返回false
Optional map(Function mapper)	如果值存在，对该值应用给定的映射方法，如果是非null的结果，返回一个描述该值的 optional，否则返回一个空Optional(值为null)
static Optional of(T value)	通过给定的value，返回一个值为给定value的Optional实例，value不能为null，若value为null，则抛出NullPointerException
static Optional ofNullable(T value)	通过给定的value，返回一个值为给定value的Optional实例，value可为null
T orElse(T other)	如果此Optional的value不为null,则返回value,否则返回给定的other对象
T orElseGet(Supplier other)	如果此Optional的value不为null,则返回value,否则通过调用给定的Supplier（供给型函数式接口）返回一个T类型的对象
T orElseThrow(Supplier exceptionSupplier)	如果此Optional的value不为null,则返回value,否则通过调用给定的Supplier创建一个Throwable
String toString()	返回非空字符串表示此Optional，适用于调试。

项目中常用的实例方法，用于解决空指针异常

isPresent()方法，如果存在值，将返回true，否则返回false。
orElse(T other)方法，如果存在值，则返回当前Optional的value，否则返回 other
ifPresent(Consumer consumer)，如果存在值，对该值应用指定的 Consumer，执行代码块，否则不做任何操作

1.2 Optional 源码

public final class Optional {
    
    private static final Optional EMPTY = new Optional<>();

    
    private final T value;

    
    private Optional() {
 this.value = null;
    }

    
    public static Optional empty() {
 @SuppressWarnings("unchecked")
 Optional t = (Optional) EMPTY;
 return t;
    }

    
    private Optional(T value) {
 this.value = Objects.requireNonNull(value);
    }

    
    public static  Optional of(T value) {
 return new Optional<>(value);
    }

    
    public static  Optional ofNullable(T value) {
 return value == null ? empty() : of(value);
    }

    
    public T get() {
 if (value == null) {
     throw new NoSuchElementException("No value present");
 }
 return value;
    }

    
    public boolean isPresent() {
 return value != null;
    }

    
    public void ifPresent(Consumer consumer) {
 if (value != null)
     consumer.accept(value);
    }

    
    public Optional filter(Predicate predicate) {
 Objects.requireNonNull(predicate);
 if (!isPresent())
     return this;
 else
     return predicate.test(value) ? this : empty();
    }

    
    public Optional map(Function mapper) {
 Objects.requireNonNull(mapper);
 if (!isPresent())
     return empty();
 else {
     return Optional.ofNullable(mapper.apply(value));
 }
    }

    
    public Optional flatMap(Function> mapper) {
 Objects.requireNonNull(mapper);
 if (!isPresent())
     return empty();
 else {
     return Objects.requireNonNull(mapper.apply(value));
 }
    }

    
    public T orElse(T other) {
 return value != null ? value : other;
    }

    
    public T orElseGet(Supplier other) {
 return value != null ? value : other.get();
    }

    
    public  T orElseThrow(Supplier exceptionSupplier) throws X {
 if (value != null) {
     return value;
 } else {
     throw exceptionSupplier.get();
 }
    }

    
    @Override
    public boolean equals(Object obj) {
 if (this == obj) {
     return true;
 }

 if (!(obj instanceof Optional)) {
     return false;
 }

 Optional other = (Optional) obj;
 return Objects.equals(value, other.value);
    }

    
    @Override
    public int hashCode() {
 return Objects.hashCode(value);
    }

    
    @Override
    public String toString() {
 return value != null
     ? String.format("Optional[\%s]", value)
     : "Optional.empty";
    }
}


1.3 Optional 简单使用

public class Person {

    //姓名
    private String name;
    //年龄
    private long age;

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

    public String getName() {
 return name;
    }

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

    public long getAge() {
 return age;
    }

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

    @Override
    public String toString() {
 return "Person{" +
  "name='" + name + ''' +
  ", age=" + age +
  '}';
    }

}

    
    @Test
    public void test() {
 Person p = new Person("张三", 18);

 // 通过给定的value，返回一个值为给定value的Optional实例，若value为null，则抛出NullPointerException
 // Optional

04-Optional类和接口中的default、static方法

Java相关栏目本月热门文章