Guava总结1-Optional 介绍

       Guava作为一个牛逼的通用工具类.提供了很多灰常不错的封装方法.可以让代码变得非常优美.一般来说,就是谁用谁知道了..

      

       按照wiki上的顺序,第一个是Optional,主要的功能是解决null值表达寓意的问题.还可以避免null值经常造成的NullPointerException..个人的感觉是,使用增加了一点代码量,提高了一些代码的自有缺陷.

       Optional 是一个抽象类,对应的实现有两个,

 其中,Absent对应就是空值时候的Optional,而Present是有非空值的Optional..

      具体的方法如下

/**
     * 获取一个空值(null值)的Optional对象
     *  对应会返回Absent对象
     */
    public static <T> Optional<T> absent();

    /**
     * 获取一个非null的Optional对象
     * 对应会返回Present对象
     */
    public static <T> Optional<T> of(T reference);

    /**
     * 静态方法,调用方无需关心nullableReference是Null还是非Null.
     * 如果是null则转换成Absent对象,如果非null则转换为Present对象
     */
    public static <T> Optional<T> fromNullable(T nullableReference);

    /**
     * 判断该Option是否有值
     */
    public abstract boolean isPresent();

    /**
     * 有值的时候返回对应的值,如果为空值对象(Absent对象),则抛出IllegalStateException异常
     */
    public abstract T get();

    /**
     * 做一个值判断,规则是,
     * 如果是有值对象(Present对象),则不管defalutValue是什么,自动返回对应的值.
     * 如果是空值对象(Absent对象),则返回defaultValue对应的值,defaultValue如果是null,也返回null
     */
    public abstract T or(T defaultValue);

    /**
     * Returns this {@code Optional} if it has a value present; {@code secondChoice}
     * 该方法从来不用.不多解释(保留英文注释)
     * otherwise.
     */
    public abstract Optional<T> or(Optional<? extends T> secondChoice);

    /**
     * Returns the contained instance if it is present; {@code supplier.get()} otherwise. If the
     * supplier returns {@code null}, a {@link NullPointerException} is thrown.
     * 该方法从来不用.不多解释(保留英文注释)
     *
     * @throws NullPointerException if the supplier returns {@code null}
     */
    @Beta
    public abstract T or(Supplier<? extends T> supplier);

    /**
     * 这个就是 or方法传入一个Null的效果.
     * 如果是有值对象(Present对象),则返回对应的值.
     * 如果是空值对象(Absent对象),则返回null
     */
    public abstract T orNull();

    /**
     * 该方法一直没搞清楚是干嘛用的..就是把Optional自动转换成一个Set.
     * 如果是有值对象(Present对象),则返回只有一个值的Set.
     * 如果是空值对象(Absent对象),则返回一个空的Set.
     * 这个方法有应用场景吗??
     */
    public abstract Set<T> asSet();

    /**
     * 安全的equals比较.不需要担心空指针问题哦
     * 如果是有值对象(Present对象),则调用对应值的equals方法.
     * 如果是空值对象(Absent对象),则
     */
    @Override
    public abstract boolean equals(Object object);

    /**
     * Returns the value of each present instance from the supplied {@code optionals}, in order,
     * skipping over occurrences of {@link Optional#absent}. Iterators are unmodifiable and are
     * evaluated lazily.
     * 自动过滤空值对象,转换成新的Iterable
     */
    public static <T> Iterable<T> presentInstances(final Iterable<? extends Optional<? extends T>> optionals);

 

  大概会用到的方法如下

 //present
        Optional<Integer> possible = Optional.<Integer>of(5);
        System.out.println(possible.isPresent());//true
        System.out.println(possible.get()); // 5
        System.out.println(possible.or(-1));//5
        System.out.println(possible.orNull());//5

        //absent
        Optional<Integer> absentValue = Optional.<Integer>absent();
        System.out.println(absentValue.isPresent());//false
        try{
            System.out.println(absentValue.get());//IllegalStateException
        } catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(absentValue.or(-1)); // -1
        System.out.println(absentValue.orNull()); // null
//
//
        //用static方法,自动帮我们创建Optional对象.
        Optional<Integer> nullValue = Optional.<Integer>fromNullable(null);
        System.out.println(nullValue.isPresent());//false
        try{
            System.out.println(nullValue.get());//IllegalStateException
        } catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(nullValue.or(-1)); // -1
        System.out.println(nullValue.orNull()); // null

 

 

写道

相信用过scala的Option的同学都知道，这个设计有多么的优美。