Optional使用

一、引言

空指针异常是导致Java应用程序失败的最常见原因。以前,为了解决空指针异常,Google公司著名的Guava项目引入了Optional类,Guava通过使用检查空值的方式来防止代码污染,它鼓励程序员写更干净的代码。受到Google Guava的启发,Optional类已经成为Java 8类库的一部分。Optional实际上是个容器:它可以保存类型T的值,或者仅仅保存null。Optional提供很多有用的方法,这样我们就不用。

二、方法介绍

1.Optional.of()或者Optional.ofNullable()

创建Optional对象,差别在于of不允许参数是null,而ofNullable则无限制。

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

2.Optional.empty()

所有null包装成的Optional对象:

Optional<Integer> optional1 = Optional.ofNullable(null);
Optional<Integer> optional2 = Optional.ofNullable(null);
System.out.println(optional1 == optional2);// true
System.out.println(optional1 == Optional.<Integer>empty());// true
 
Object o1 = Optional.<Integer>empty();
Object o2 = Optional.<String>empty();
System.out.println(o1 == o2);// true

3.isPresent()

判断值是否存在

Optional<Integer> optional2 = Optional.ofNullable(null);// isPresent判断值是否存在
System.out.println(optional1.isPresent() == true);
System.out.println(optional2.isPresent() == false);

4.ifPresent(Consumer consumer)

如果option对象保存的值不是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);
	}
});

5.orElse(value)

如果optional对象保存的值不是null,则返回原来的值,否则返回value

Optional<Integer> optional1 = Optional.ofNullable(1);
Optional<Integer> optional2 = Optional.ofNullable(null);
 
// orElse
System.out.println(optional1.orElse(1000) == 1);// true
System.out.println(optional2.orElse(1000) == 1000);// true

6.orElseGet(Supplier supplier)

功能与orElse一样,只不过orElseGet参数是一个对象

Optional<Integer> optional1 = Optional.ofNullable(1);
Optional<Integer> optional2 = Optional.ofNullable(null);
 
System.out.println(optional1.orElseGet(() -> {
	return 1000;
}) == 1);//true
 
System.out.println(optional2.orElseGet(() -> {
	return 1000;
}) == 1000);//true

7.orElseThrow()

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

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();
}

8.filter(Predicate)

判断Optional对象中保存的值是否满足Predicate,并返回新的Optional。

Optional<Integer> optional1 = Optional.ofNullable(1);
Optional<Integer> optional2 = Optional.ofNullable(null);
 
Optional<Integer> filter1 = optional1.filter((a) -> a == null);
Optional<Integer> filter2 = optional1.filter((a) -> a == 1);
Optional<Integer> filter3 = optional2.filter((a) -> a == null);
System.out.println(filter1.isPresent());// false
System.out.println(filter2.isPresent());// true
System.out.println(filter2.get().intValue() == 1);// true
System.out.println(filter3.isPresent());// false

9.map(Function)

对Optional中保存的值进行函数运算,并返回新的Optional(可以是任何类型)

Optional<Integer> optional1 = Optional.ofNullable(1);
Optional<Integer> optional2 = Optional.ofNullable(null);
 
Optional<String> str1Optional = optional1.map((a) -> "key" + a);
Optional<String> str2Optional = optional2.map((a) -> "key" + a);
 
System.out.println(str1Optional.get());// key1
System.out.println(str2Optional.isPresent());// false

10.flatMap()

功能与map()相似,差别请看如下代码。flatMap方法与map方法类似,区别在于mapping函数的返回值不同。map方法的mapping函数返回值可以是任何类型T,而flatMap方法的mapping函数必须是Optional。

Optional<Integer> optional1 = Optional.ofNullable(1);
 
Optional<Optional<String>> str1Optional = optional1.map((a) -> {
	return Optional.<String>of("key" + a);
});
 
Optional<String> str2Optional = optional1.flatMap((a) -> {
	return Optional.<String>of("key" + a);
});
 
System.out.println(str1Optional.get().get());// key1
System.out.println(str2Optional.get());// key

11.T get()

如果在这个Optional中包含这个值,返回值,否则抛出异常:NoSuchElementException

12.boolean isPresent()

如果值存在则方法会返回true,否则返回 false。

13.fromNullable

Optional.absent():获得一个Optional对象,其内部包含了空值
Optional.fromNullable(T):将一个T的实例转换为Optional对象,T的实例可以不为空,也可以为空。

### 正确使用 `Optional` 的编程方式 #### 使用场景 `Optional` 是 Java 8 中引入的一个容器类,旨在减少因返回值为 `null` 而引发的空指针异常。它通过封装可能为空的对象来强制开发者显式处理潜在的 `null` 值。 #### 创建 `Optional` 对象 可以通过三种主要方法创建 `Optional` 实例[^2]: - **`Optional.empty()`**: 返回一个不包含任何值的 `Optional`。 - **`Optional.of(T value)`**: 返回一个包含指定非空值的 `Optional`。如果传入的是 `null`,会抛出 `NullPointerException`。 - **`Optional.ofNullable(T value)`**: 如果参数为 `null`,则返回一个空的 `Optional`;否则返回包含该值的 `Optional`。 以下是具体示例代码: ```java // 使用 empty() Optional<String> emptyOptional = Optional.empty(); // 使用 of() Optional<String> nonNullValue = Optional.of("Hello"); // 使用 ofNullable() Optional<String> nullableValue = Optional.ofNullable(null); nullableValue.ifPresentOrElse( System.out::println, () -> System.out.println("No Value Present") ); ``` #### 处理 `Optional` 内部值 可以利用多种方法安全地访问和操作 `Optional` 容器中的值: 1. **`isPresent()` 和 `ifPresent(Consumer<? super T>)`** - 检查是否有值存在并执行相应逻辑。 ```java Optional<String> optStr = Optional.of("World"); if (optStr.isPresent()) { System.out.println(optStr.get()); } optStr.ifPresent(value -> System.out.println("Value is: " + value)); ``` 2. **`orElse(T other)`** - 当 `Optional` 不含有效值时提供默认替代项。 ```java String result = Optional.ofNullable(null).orElse("Default"); System.out.println(result); // 输出 Default ``` 3. **`orElseGet(Supplier<? extends T> supplier)`** - 类似于 `orElse` 方法,但它允许延迟计算默认值直到必要时刻才触发。 ```java String lazyResult = Optional.ofNullable(null).orElseGet(() -> computeExpensiveOperation()); ``` 4. **`map(Function<? super T, ? extends U> mapper)`** - 将当前值映射到另一个新类型的值上形成新的 `Optional`。 5. **`flatMap(Function<? super T, ? extends Optional<U>> mapper)`** - 执行函数转换的同时保持结果仍然是 `Optional` 形态而不嵌套额外层[^1]。 下面是一个综合运用这些特性的例子: ```java public class User { private final Address address; public User(Address address) { this.address = address; } public Optional<Address> getAddress() { return Optional.ofNullable(address); } } public class Address { private final String city; public Address(String city) { this.city = city; } public String getCity() { return city; } } public static void main(String[] args) { User user = new User(new Address("New York")); Optional<String> cityName = Optional.of(user) .flatMap(User::getAddress) .map(Address::getCity); cityName.ifPresent(System.out::println); // 输出 New York } ``` #### 避免滥用 `Optional` 尽管 `Optional` 提供了许多便利功能,但也需要注意其适用范围: - 切勿将其作为字段成员变量存储。 - 不应过度依赖链式调用来掩盖复杂业务逻辑。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值