Java 8 新特性之六-Optional类

  

简介

Optional类是一个可以为null的容器对象. 使用isPresent()方法判断值是否为空, 如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

语法

//伪代码
Optional<T> optional = cmsPageRepository.findById("  ");
        if (optional.isPresent()){ //判断是否为空
            CmsPage cmsPage = optional.get();
            ……
        }

Optional类API

序号	方法 & 描述
1	static Optional empty() 返回空的 Optional 实例。
2	boolean equals(Object obj) 判断其他对象是否等于 Optional。
3	Optional filter(Predicate<? super predicate) 如果值存在，并且这个值匹配给定的 predicate，返回一个Optional用以描述这个值，否则返回一个空的Optional。
4	Optional flatMap(Function<? super T,Optional> mapper) 如果值存在，返回基于Optional包含的映射方法的值，否则返回一个空的Optional
5	T get() 如果在这个Optional中包含这个值，返回值，否则抛出异常：NoSuchElementException
6	int hashCode() 返回存在值的哈希码，如果值不存在 返回 0。
7	void ifPresent(Consumer<? super T> consumer) 如果值存在则使用该值调用 consumer , 否则不做任何事情。
8	boolean isPresent() 如果值存在则方法会返回true，否则返回 false。
9	Optional map(Function<? super T,? extends U> mapper)如果有值，则对其执行调用映射函数得到返回值。如果返回值不为 null，则创建包含映射返回值的Optional作为map方法返回值，否则返回空Optional。
10	static Optional of(T value) 返回一个指定非null值的Optional。
11	static Optional ofNullable(T value) 如果为非空，返回 Optional 描述的指定值，否则返回空的 Optional。
12	T orElse(T other) 如果存在该值，返回值， 否则返回 other。
13	T orElseGet(Supplier<? extends T> other) 如果存在该值，返回值， 否则触发 other，并返回 other 调用的结果。
14	T orElseThrow(Supplier<? extends X> exceptionSupplier) 如果存在该值，返回包含的值，否则抛出由 Supplier 继承的异常
15	String toString() 返回一个Optional的非空字符串，用来调试

注意: 这些方法继承自java.lang.Object类

测试Optional

import java.util.Optional;

/**
 * Java 8 新特性之六-Optional类
 *
 * @author C-jerry
 * @date 2020/6/2 19:24
 */
public class testOptional {
    public static void main(String[] args) {
        testOptional testOptional = new testOptional();
        //testOptional.whenCreateEmptyOptional_thenNull();

        //testOptional.whenCreateOfEmptyOptional_thenNullPointerException(null);
        //testOptional.whenCreateOfEmptyOptional_thenNullPointerException2(null);

        //testOptional.whenCreateOfEmptyOptional_thenOk();

        //testOptional.whenEmptyValue_thenReturnDefault();

        /**
         * 结果
         * orElse
         * 创造了对象
         * orElseGet
         * 创造了对象
         */
       // testOptional.givenEmptyValue_whenCompare_thenOk();

        /**
         * 结果
         * orElse
         * 创造了对象
         * orElseGet
         */
        //testOptional.givenEmptyValue_whenCompare_thenOk2();

        //testOptional.whenThrowException_thenOk(null);

        //testOptional.whenMap_thenOk();

        testOptional.whenFilter_thenOk();

    }

    /**
     * 由于emptyOpt为null所以报异常NoSuchElementException
     * Exception in thread "main" java.util.NoSuchElementException: No value present
      */
    public void whenCreateEmptyOptional_thenNull() {
        Optional<User> emptyOpt = Optional.empty();//可能为空null
        emptyOpt.get();
    }

    /**
     * of()方法 --如果传入的值为null会报空指针异常
     *    Exception in thread "main" java.lang.NullPointerException
     *    没有完全摆脱NullPointerException, 在明确
     */
    public void whenCreateOfEmptyOptional_thenNullPointerException(User user) {

        Optional<User> optional = Optional.of(user);//可能为空null

    }

    /**
     * ofNullable()--即使传入的值为空. 也不会抛出异常
     * 底层是封装的empty(),of(value), 为null的时候会走empty(),
     *     public static <T> Optional<T> ofNullable(T value) {
     *         return value == null ? empty() : of(value);
     *     }
     *     empty()底层会创建一个optional对象
     *         -- private static final Optional<?> EMPTY = new Optional<>();
     * 如上例, 当值为null时, 也就是说该方法只要get(),同样会抛出异常
     * @param user
     */
    public void whenCreateOfEmptyOptional_thenNullPointerException2(User user) {

        Optional<User> optional = Optional.ofNullable(user);//可能为空null

        //optional.get();
    }

    /**
     * 检查是否为null
     *      isPresent()
     *      ifPresent(Consumer<? super T> consumer):需要接收一个参数
     */
    public void whenCreateOfEmptyOptional_thenOk() {
        User user = new User("22");
        user=null;
        Optional<User> optional = Optional.ofNullable(user);//可能为空null
        if (optional.isPresent()){
            //值需要存在
            optional.get();
        }

//        optional.ifPresent(uu->{
//            System.out.println(uu.i);
//       });
    }

    /**
     * orElse(T other), 有值就返回值, 没有值就返回传递给他的值
     *  other--为null也不会报异常
     *  如果对象值是null, 则返回orElse()给定的默认值, 如果对象初始值不为null,则忽略
     */
    public void whenEmptyValue_thenReturnDefault() {
        User user = new User("22");
        User user2=null;

        //User optional = Optional.ofNullable(user2).orElse(null);
        User optional = Optional.ofNullable(user2).orElse(user);

        //user 对象是空的，所以返回了作为默认值的 user2。
        System.out.println(optional);

    }
//-----------------------------------------------------------------
    /**
     * orElse() 和 orElseGet() 的不同之处
     *      两个 Optional  对象都包含非空值，两个方法都会返回对应的非空值。
     *      不过，orElse() 方法仍然创建了 User 对象。与之相反，orElseGet() 方法不创建 User 对象。
     *      平常没有太大的影响. 但是执行较密集调用的时候, 性能差异会很大(eg: 数据查询)
     */

    //情况一: 对象值为null
    public void givenEmptyValue_whenCompare_thenOk(){
        User user = null;
        System.out.println("orElse");
        User result = Optional.ofNullable(user).orElse(createNewUser());

        System.out.println("orElseGet");
        User result2 = Optional.ofNullable(user).orElseGet(() -> createNewUser());
    }
    //情况二
    public void givenEmptyValue_whenCompare_thenOk2(){
        User user = new User("ww");
        System.out.println("orElse");
        User result = Optional.ofNullable(user).orElse(createNewUser());

        System.out.println("orElseGet");
        User result2 = Optional.ofNullable(user).orElseGet(() -> createNewUser());
    }

    private User createNewUser() {

        System.out.println("创造了对象");
        return new User("Creating New User");
    }

//-----------------------------------------------------------------
    /**
     * 返回异常: orElseThrow()
     *      它会在对象为空的时候抛出异常，而不是返回备选的值：
     */
    public void whenThrowException_thenOk(User user){
        User result = Optional.ofNullable(user)
                .orElseThrow( () -> new IllegalArgumentException());
    }

//-----------------------------------------------------------------
    /**
     * 转换值
     *     :map()调用作为参数的函数, 值会包装在Optional中
     *     :flatMap()同理
     */
    public void whenMap_thenOk(){
        User user = new User("map转换Optional");
        //将Optional转换成Boolean
        Boolean optional = Optional.ofNullable(user)
                .map(u -> u.equals(user)).orElse(false);

        System.out.println(optional);
    }

//-----------------------------------------------------------------
    /**
     * 过滤值
     *      : 按条件过滤值-->filter()方法
     *      filter() 接受一个 Predicate 参数，返回测试结果为 true 的值。如果测试结果为 false，会返回一个空的 Optional。
     *      filter()底层如下:
     *      public Optional<T> filter(Predicate<? super T> predicate) {
     *         Objects.requireNonNull(predicate);
     *         if (!isPresent())
     *             return this;
     *         else
     *             return predicate.test(value) ? this : empty();
     *     }
     */
    public void whenFilter_thenOk() {
        //User user = new User();//user=null
        User user = new User("测试filter()");//user=测试filter()
        //user=null-->创建一个Optional.empty()对象, 不为空返回true, 直接返回user的值
        Optional<User> optional = Optional.ofNullable(user)
                .filter(u -> u!=null);
        System.out.println(optional.get());
    }


//-----------------------------------------------------------------
    /**
     * Optional 类的链式方法
     */
    //TODO: 待测试
}

class User{
    private String i;
    public User(){}
    public User(String i) {
        this.i=i;
    }
    public void  getI(){
        System.out.println(i);
    };

    @Override
    public String toString() {
        return "User{" +
                "i='" + i + '\'' +
                '}';
    }
}