Optional基础用法

Optional

常用方法

Optional.of()

// 参数不能是null
Optional<Integer> optional1 = Optional.of(1);

Optional.of()或者Optional.ofNullable()：创建Optional对象，差别在于of不允许参数是null，而ofNullable则无限制。

Optional.ofNullable()

Optional.ofNullable() 是 Java 8 中的一个方法，它返回一个 Optional 类型的对象。Optional 类型是一个容器，它可以保存一个值，该值可以为 null。Optional.ofNullable() 方法的作用是将一个可能为 null 的值包装到 Optional 容器中，如果该值为 null，则返回一个空的 Optional 对象，否则返回一个包含该值的 Optional 对象。

使用 Optional.ofNullable() 可以有效地避免空指针异常，因为它可以让我们在获取一个可能为 null 的对象时，先判断该对象是否为空，从而避免出现空指针异常。例如：

javaCopy codeString str = null;
Optional<String> optionalStr = Optional.ofNullable(str);
if (optionalStr.isPresent()) {
    // str 不为 null，进行相关操作
    String result = optionalStr.get();
} else {
    // str 为 null，进行相关操作
}

需要注意的是，在使用 Optional 时，我们应该尽可能避免使用 get() 方法获取 Optional 容器中的值，而是应该使用 orElse() 方法或者 orElseThrow() 方法来获取一个默认值或抛出异常。因为 get() 方法在容器为空时会抛出 NoSuchElementException 异常。

isPresent() / ifPresent()

isPresent()判断值是否存在

Optional<Integer> optional1 = Optional.ofNullable(1);
Optional<Integer> optional2 = Optional.ofNullable(null);

// isPresent判断值是否存在
System.out.println(optional1.isPresent() == true);
System.out.println(optional2.isPresent() == false);

ifPresent(Consumer consumer), 如果Optional对象保存的值不是null, 则调用consumer对象,否则不调用

Optional<Integer> optional1 = Optional.ofNullable(1);
Optional<Integer> optional2 = Optional.ofNullable(null);

// 如果不是null,调用Consumer
optional1.ifPresent(new Consumer<Integer>() {
    @Override
    public void accept(Integer t) {
    	System.out.println("value is " + t);
    }
});

// null,不调用Consumer
optional2.ifPresent(new Consumer<Integer>() {
    @Override
    public void accept(Integer t) {
    	System.out.println("value is " + t);
    }
});

测试

// 如果值存在返回true,否则返回false
public boolean isPresent() {
    return value != null;
}
 
// 如果Optional实例有值则为其调用consumer ,否则不做处理。
public void ifPresent(Consumer<? super T> consumer) {
    if (value != null)
        consumer.accept(value);
    
    
 public class OptionalTest {
     public static void main(String[] args) {
         User user = new User();
         Optional<User> optional = Optional.ofNullable(user);
         optional.ifPresent(s -> System.out.println(s));
     }
 }

Optional.empty()

Optional.empty( )：所有null包装成的Optional对象：

Optional<Integer> o1 = Optional.<Integer>empty()
Optional<Integer> o2 = Optional.ofNullable(null)
print(o1 == o2) // true

获取Optional里面的对象

get()

注意:在调用get()方法之前, 一定要先进行isPresent()方法判断是否存在值

//get
Optional<String> optional1 = Optional.of("javaone");
if (optional1.isPresent()){
   String value = optional1.get();
}

orElse(value)

返回值（如果存在）；反之，返回其他。

// 如果Optional中的值不为空，则返回Optional中的值，如果为空，则返回other值，
public T orElse(T other) {
    return value != null ? value : other;
}


//orElse
String nullName = null;
String name = Optional.ofNullable(nullName).orElse("default_name");

orElseGet()

返回值（如果存在）；否则，调用other并返回该调用的结果。

该orElseGet() 方法类似于 orElse()。但是，如果没有Optional值，则不采用返回值，而是采用供应商功能接口，该接口将被调用并返回调用的值：

// 如果Optional中存在值，则返回值，否则返回other调用的结果
public T orElseGet(Supplier<? extends T> other) {
    return value != null ? value : other.get();
}

//orElseGet
String name = Optional.ofNullable(nullName).orElseGet(() -> "john");

orElseThrow()

值不存在则抛出异常，存在则什么不做，有点类似Guava的Precoditions

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

Optional<Integer> optional1 = Optional.ofNullable(1);
Optional<Integer> optional2 = Optional.ofNullable(null);

optional1.orElseThrow(()->{throw new IllegalStateException();});

try{
    // 抛出异常
    optional2.orElseThrow(()->{throw new IllegalStateException();});
}catch(IllegalStateException e ){
	e.printStackTrace();
}

测试

 String value = "2";
 String orElse = Optional.ofNullable(value).orElse("1");  
 System.out.println(orElse);  //2  
         
 String value = null;
 String orElse = Optional.ofNullable(value).orElse("1"); 
 System.out.println(orElse);  //1
 
 -------------------------------------------------------
 
  public class OptionalTest {
     public static void main(String[] args) {
         String value = null;
         String orElse = Optional.ofNullable(value).orElseGet(OptionalTest::get);
         System.out.println(orElse);  // 123
         
         String value = "2";
         String orElse = Optional.ofNullable(value).orElseGet(OptionalTest::get);
         System.out.println(orElse);  // 2                                       
     }
 ​
     public static String get(){
         return "123";
     }
 }
 
  -------------------------------------------------------
  
   public class OptionalTest {
     public static void main(String[] args) {
         String value = null;
         String orElse = Optional.ofNullable(value).orElseThrow(() -> new RuntimeException("不存在值"));
         System.out.println(orElse);
     }
 }