Optional使用和避免Null - Google Guava

最新推荐文章于 2025-06-10 06:00:00 发布

原创最新推荐文章于 2025-06-10 06:00:00 发布 · 1.4k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#Optional

必须熟悉的常用库专栏收录该内容

50 篇文章

订阅专栏

本文深入解析Guava库中的Optional类，介绍其如何处理可能为null的对象引用，避免空指针异常，提供了一系列实用方法，如of、absent、fromNullable等，以及如何使用这些方法查询和操作Optional实例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Guava Optional 类

Optional 用于包含非空对象的不可变对象。 Optional对象，用于不存在值表示null。这个类有各种实用的方法，以方便代码来处理为可用或不可用，而不是检查null值。

常用方法

方法类型	方法描述
`static <T> Optional<T>`	`absent()` 返回没有包含引用的Optional实例。
`abstract Set<T>`	`asSet()` 返回一个不可变的单集的唯一元素所包含的实例(如果存在)，否则为一个空的不可变的集合。
`abstract boolean`	`equals(@Nullable Object object)` 如果object是Optional实例，并且包含的引用彼此相等或两者都不存在，则返回true.
`static <T> @Nullable Optional<T>`	`fromJavaUtil(Optional<T> javaUtilOptional)` 返回给定的java.util.Optional，等效com.google.common.base.Optional值，如果参数为null，则返回null
`static <T> Optional<T>`	`fromNullable(T nullableReference)` 如果 nullableReference 非null，返回包含该引用的Optional实例，否则返回 `absent()`.
`abstract T`	`get()` 返回必须存在的实例.
`abstract int`	`hashCode()` 返回此实例的哈希码。
`abstract boolean`	`isPresent()` 如果包含（非null）实例，则返回true。
`static <T> Optional<T>`	`of(T reference)` 返回包含给定非null引用的Optional实例。
`abstract Optional<T>`	`or(Optional<? extends T> secondChoice)` 如果它有一个值存在，返回Optional，否则返回secondChoice。
`abstract T`	`or(Supplier<? extends T> supplier)` 如果包含实例，则返回该实例，否则返回`supplier.get()`。
`abstract T`	`or(T defaultValue)` 如果包含实例，则返回该实例，否则返回 `defaultValue` 默认值。
`abstract T`	`orNull()` 返回包含的实例（如果存在），否则返回null。
`static <T> Iterable<T>`	`presentInstances(Iterable<? extends Optional<? extends T>> optionals)` 从提供的选项中返回每个当前实例的值，按顺序跳过absent（）的出现次数。
`Optional<T>`	`toJavaUtil()` 返回 java.util.Optional 等效值
`static <T> Optional<T>`	`toJavaUtil(@Nullable Optional<T> googleOptional)` 返回给定com.google.common.base.Optional的等效java.util.Optional值，如果参数为null，则返回null。
`abstract String`	`toString()` 返回此实例的字符串表示形式。
`abstract <V> Optional<V>`	`transform(Function<? super T,V> function)` 如果实例存在，则使用给定的函数进行转换; 否则返回 `absent()`。

创建 Optional 实例（以下都是静态方法）：

List<String> list = null;

Optional.of：创建一个不能为null值的Optional

try{
    Optional<List<String>> list1 = Optional.of(list); //这里抛异常java.lang.NullPointerException异常
} catch (NullPointerException e){
    e.printStackTrace();
}

Optional.absent：创建一个没有包含引用Optional,就是为NULL的

Optional<List<String>> list3 = Optional.absent();
Optional<String[]> arr1 = Optional.absent();

Optional.fromNullable：创建允许null值的Optional

try {
    Optional<List<String>> listOptional = Optional.fromNullable(list);
} catch (Exception e) {
    e.printStackTrace();
}

用 Optional 实例查询引用（以下都是非静态方法）：

Optional.isPresent：检查值是否存在

Optional<List<String>> listOptional = Optional.fromNullable(list);
if(listOptional.isPresent()){
        System.out.println("值存在...");
}

Optional.get：返回必须存在的实例.

Optional<List<String>> listOptional = Optional.fromNullable(list);
if(listOptional.isPresent()){
    System.out.println("值存在...");
    List<String> strings = listOptional.get();
} else if(listOptional.isPresent() == false){
    System.out.println("值不存在...");
    try{
        List<String> strings = listOptional.get(); // 此处抛出：java.lang.IllegalStateException
    } catch (Exception e){
        e.printStackTrace();
    }
}

Optional.or：如果值不为空，就返回值，否则返回一个默认值

Optional<List<String>> listOptional = Optional.fromNullable(list);
List<String> resultList1 = listOptional.or(ArrayList::new);

Optional.or：如果值不为空，就返回值，否则返回一个包含引用的Optional

Optional<List<String>> resultList2 = listOptional.or(Optional.fromNullable(
        Lists.newArrayList("值1", "值2")));

Optional.orNull：返回包含的实例（如果存在），否则返回null。

Optional<List<String>> listOptional = Optional.fromNullable(list);
List<String> result = listOptional.orNull();
System.out.println(result); // null

Optional.toJavaUtil：将 com.google.common.base.Optional 转换为 java.util.Optional

// 方式一：
java.util.Optional<List<String>> strings = Optional.fromNullable(list).toJavaUtil();
// 方式二
java.util.Optional<List<String>> strings1 = Optional.toJavaUtil(Optional.fromNullable(list));

Optional.transform：如果实例存在，则使用给定的函数进行转换; 否则返回 absent()。

List<Integer> list1 = Lists.newArrayList(1, 2, 3);
Optional<List<Integer>> listOptional = Optional.fromNullable(list1);
listOptional.transform(object -> {
    for (int i = 0; i < object.size(); i++) {
        object.set(i, object.get(i) + 1);
    }
    return object; // Optional.of([2, 3, 4])
});

Optional<List<String>> optional = Optional.fromNullable(list);
listOptional.transform(object -> {
    return object; // Optional.absent()
});

Optional.presentInstances：将参数optionals中为null的optional剔除，同时返回值对象的Iterable

List<Optional<Integer>> list = Lists.newArrayList(
        Optional.fromNullable(1),
        Optional.fromNullable(null),
        Optional.fromNullable(2)
);
Iterable<Integer> it = Optional.presentInstances(list);
it.forEach(System.err::println); // 1, 2

Optional.asSet：返回一个不可变的单集的唯一元素所包含的实例(如果存在)，否则为一个空的不可变的集合。

Optional<Integer> nullOptional = Optional.absent();
Set<Integer> set1 = nullOptional.asSet();
System.out.println(set1.size()); // 0

Optional<Integer> optional = Optional.of(5);
Set<Integer> set2 = optional.asSet();
System.out.println(set2.size()); // 1