目录
2.2 Optional.ofNullable(value)
一、Optional简介
Optional是java1.8引入的容器对象,它提供了非常丰富的API，主要是用于解决空指针异常的问题。
二、构建Optional对象三种方式
2.1 Optional.of(value)
/**
* 返回一个Optional给定的非null值
* @param <T> 值类型
* @param value 描述的值，必须是非null
* @return 返回Optional对象
* @throws 如果value为空,抛出空指针异常
*/
public static <T> Optional<T> of(T value) {
return new Optional<>(value);
}
2.1.1 使用案例
Optional<String> optional = Optional.of("hello optional");
System.out.println(optional.get()); //输出hello optional2.2 Optional.ofNullable(value)
/**
* 返回一个描述给定值的Optional,如果不为null,则返回一个有值的Optional对象
* @param <T> 值类型
* @param value 描述的值，可能为null
* @return 返回Optional对象,如果值为null,就返回一个null的Optional对象
*/
public static <T> Optional<T> ofNullable(T value) {
return value == null ? empty() : of(value);
}2.2.1 使用案例
Optional<String> optional11 = Optional.ofNullable("hello optional222");
Optional<String> optional2 = Optional.ofNullable(null);
System.out.println("optional12:"+optional11.get());//输出hello optional222
System.out.println("optional1:"+optional2.get());//抛出.NoSuchElementException异常,不存在任何值2.3 Optional.empty()
/**
* 返回一个空的Optional实例，此Optional没有值
* @param <T> 不存在的类型值
* @return 返回一个空的Optional
*/
public static<T> Optional<T> empty() {
@SuppressWarnings("unchecked")
Optional<T> t = (Optional<T>) EMPTY;
return t;
}2.3.1 使用案例
Optional<String> optional3 = Optional.empty();
System.out.println(optional2.get());//抛出.NoSuchElementException异常,不存在任何值三、Optional常用的api解析和使用案例
3.1 isPresent
/**
* 如果存在值就返回true，如果不存在就返回false
*/
public boolean isPresent() {
return value != null;
}3.1.1 使用案例
Optional<String> optional = Optional.of("hello optional");
if(optional.isPresent()){
System.out.println("当前的option不为空,输出为:"+optional.get()); //输出hello optional
}3.2 ifPresent
/**
* 如果Optional对象存在值，则执行给定的操作，否则不执行任何操作
*/
public void ifPresent(Consumer<? super T> consumer) {
if (value != null)
consumer.accept(value);
}3.2.1 使用案例
Optional<String> optional11 = Optional.ofNullable("hello optional222");
String str = "string string";
optional11.ifPresent(o -> System.out.println(str));//输出string string3.3 orElse
/**
* 如果存在值，则返回该值，否则返回other
* 参数:可以为任意值，也可以为null
*/
public T orElse(T other) {
return value != null ? value : other;
}3.3.1 使用案例
String s = null;
String optionStr = Optional.ofNullable(s).orElse("java");
System.out.println("optionStr:"+optionStr); //optionStr为空所以输出java
3.4 orElseGet
/**
* 如果存在值，则返回该值，否则返回由函数提供的结果
* 参数:需要返回的函数
*/
public T orElseGet(Supplier<? extends T> other) {
return value != null ? value : other.get();
}3.4.1 使用案例
class User {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public static void main(String[] args) {
User user = null;
user = Optional.ofNullable(user).orElseGet(()->{
User user1 = new User();
user1.setName("java");
return user1;
});
System.out.println("user:"+user.getName()); //输出 user:java
}3.4.2 orElse和orElseGet的区别
3.5 orElseThrow
/**
* 如果存在值，则返回该值,否则抛出由异常函数提供的异常
* 参数:exceptionSupplier 产生要抛出异常的提供函数
* 参数类型:X-引发的异常
* 抛出:如果不存在任何值，抛出NullPointerException,如果不存在任何值并且异常函数提供为null
* 注意点:带有空参数列表的对异常构造函数的方法引用可用作提供者
*/
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
if (value != null) {
return value;
} else {
throw exceptionSupplier.get();
}
}3.5.1 使用案例
class User {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public static void main(String[] args) {
User user = new User();
user.setName("java");
User user1 = Optional.ofNullable(user).orElseThrow(()->{
return new RuntimeException(); //因为user有值，所以不会抛出异常
});
System.out.println("user1:"+user1.getName()); // 输出user1:java
user = null;
User user2 = Optional.ofNullable(user).orElseThrow(()->{
return new RuntimeException(); //因为user为空，抛出需要返回的异常,这里为运行时异常
});
}
3.6 map
/**
* 如果存在值,则返回一个Optional，将给定映射函数应用于该值的结果，否则返回一个空的Optional
* 如果映射函数返回null结果，则此方法返回空的Optional
*/
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));
}
}3.6.1 使用案例
class User {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public static void main(String[] args) {
User user = new User();
user.setName("java");
Optional<String> optionalUser = Optional.ofNullable(user).map(User::getName);
System.out.println(optionalUser.get());// 输出 java
}3.7 filter
/**
* 如果存在一个值,并且该值与给定的值匹配，则返回秒速该值的Optional,否则返回一个空的Optional
*/
public Optional<T> filter(Predicate<? super T> predicate) {
Objects.requireNonNull(predicate);
if (!isPresent())
return this;
else
return predicate.test(value) ? this : empty();
}3.7.1 使用案例
public static void main(String[] args) {
User user = new User();
user.setName("java");
Optional<String> optionalUser = Optional.ofNullable(user).filter(o->o.getName().equals("java")).map(User::getName);
if(optionalUser.isPresent()){
System.out.println(optionalUser.get());// 输出 java
}else{
System.out.println("Optiaon为空");
}
}3.8 or
/**
* 如果存在值时,返回一个Optional描述的值，否则将返回一个Optional产生通过供给的功能
* 参数:供应商-产生要返回的Optional的供应功能
* 返回值:如果一个值存在,返回一个Optional描述此值的Optional,否则Optional所生产的供应功能
* 抛出:NullpointerException如果提供函数的null或产生的null结果
*/
public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier) {
Objects.requireNonNull(supplier);
if (isPresent()) {
return this;
} else {
@SuppressWarnings("unchecked")
Optional<T> r = (Optional<T>) supplier.get();
return Objects.requireNonNull(r);
}
}3.8.1 使用案例
public static void main(String[] args) {
User user = null;
Optional<User> optionalUser = Optional.ofNullable(user).or(() -> {
User user1 = new User();
user1.setName("java");
return Optional.of(user1);
});
if (optionalUser.isPresent()) {
System.out.println(optionalUser.get().getName()); //输出 java
} else {
System.out.println("为空");
}
}3.9 stream
/**
* 如果存在值,则返回仅包含该值的顺序Stream，否则返回一个空的Stream
* 返回值:Stream
*/
public Stream<T> stream() {
if (!isPresent()) {
return Stream.empty();
} else {
return Stream.of(value);
}
}3.9.1 使用案例
public static void main(String[] args) {
User user = new User();
user.setName("java");
Stream<User> userStream = Optional.ofNullable(user).stream().filter(u->u.getName().equals("java"));
userStream.forEach(u->{
System.out.println(u.getName());
});
}参考文档:java中Optional的使用详细解析_java_脚本之家
