Optional使用和避免Null - Google Guava

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