【无标题】Java中的Optional

在我们日常的开发中，我们经常会遇到 NullPointerException。如何才能优雅的处理NPE？这里告诉大家一个较为流行的方法

java.util.Optional
使用Optional来修饰对象，表示这个对象可能为null。在使用时，就要加以注意，必须要考虑该值为null的场景。

使用Optional构建对象
// 创建一个空的car
Optional car = Optional.empty();

    // 使用of创建，of的值一定不能是null，否则赋值阶段就报 NullPointerException
    /**
     *  if (obj == null)
     *             throw new NullPointerException();
     */
    Car car1 = new Car();
    Optional ocar1 = Optional.of(car1);

    // 创建一个可以为null的Optional，该方法支持car为null，但是会在用到car的地方抛出异常，但不是空指针异常。
    Car car2 = new Car();
    Optional ocar2 = Optional.ofNullable(car2);
    System.out.println(ocar2.get());
    Optional ocar22 = Optional.ofNullable(null);
1
2
3
4
5
6
7
8
9
10
11
12
13

获取Optional中的对象
get: 这是最不安全的方法。如果变量存在就返回，不存在的话则会抛出NoSuchElementException的异常。所以，get()的使用场景一定是十分确定Optional修饰的值一定是有内容的，否则不建议使用。

/**
         * public T get() {
         *         if (value == null) {
         *             throw new NoSuchElementException("No value present");
         *         }
         *         return value;
         *     }
         */
        String name = car.getInsurance().get().getName();
        System.out.println(name);
1
2
3
4
5
6
7
8
9
10

orElse: 作用和get一样，但是没有值时可以使用默认值

/**
         *     public T orElse(T other) {
         *         return value != null ? value : other;
         *     }
         */
        String orName = car.getInsurance().orElse(new Insurance()).getName();
        System.out.println(orName);
1
2
3
4
5
6
7

orElseGet: orElse的延时版本。只有当val为空时，才会创建defleat value

/**
         * public T orElseGet(Supplier supplier) {
         *         return value != null ? value : supplier.get();
         *     }
         */
        String getElseName = car.getInsurance().orElseGet(Insurance::new).getName();
        System.out.println("getElseName " + getElseName);
1
2
3
4
5
6
7

orElseThrow: 和orElse类似，只是当value不存在时抛出异常

public T orElseThrow() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }
1
2
3
4
5
6

ifPresent: 判断值存在之后再操作，不存在就不操作

/**
         * public void ifPresent(Consumer action) {
         *         if (value != null) {
         *             action.accept(value);
         *         }
         *     }
         */
        car.getInsurance().ifPresent(ins -> {
            String pname = ins.getName();
            System.out.println("inPresent " + pname);
        });
1
2
3
4
5
6
7
8
9
10
11

Optional 中map和flatmap的差别

Optional> mCar = optionalPerson.map(Person::getCar);
Optional flatMapCap = optionalPerson.flatMap(Person::getCar);
1
2

map

public  Optional map(Function mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent()) {
            return empty();
        } else {
            //  返回值使用Optional包装
            return Optional.ofNullable(mapper.apply(value));
        }
    }
1
2
3
4
5
6
7
8
9

public  Optional flatMap(Function> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent()) {
            return empty();
        } else {
            @SuppressWarnings("unchecked")
            Optional r = (Optional) mapper.apply(value);
            // 返回值没有包装，直接是Optional对象，只做了一次判null
            return Objects.requireNonNull(r);
        }
    }
1
2
3
4
5
6
7
8
9
10
11