【Java8】Optional类

概念

Optional对象或者是对一个T类型对象的封装，或者表示不是任何对象
它比一般指向T类型的引用更安全，因为它不会返回null

方法	描述
flatMap	值存在，执行mapping调用，返回Optional类型的值；不存在，返回空的Optional对象
get	值存在，用Optional封装返回；不存在，抛出NoSuchElementException异常
ifPresent	值存在，执行该值方法调用；不存在，什么也不做
isPresent	值存在，返回true；不存在，返回false
map	值存在，执行mapping调用
of	用Optional封装后返回，如果该值为null，抛出NullPointerException异常
ofNullbale	用Optional封装后返回，如果改值为null，返回一个空的Optional对象
ofElse	值存在，返回值；不存在，返回一个默认值
orElseGet	值存在，返回值；不存在，返回一个Supplier接口生成值
orElseThrow	值存在，返回值；不存在，返回一个Supplier接口生成异常

使用Optional

数据模型代码

public class Person{
    private Optional<Car> car;
    public Optional<Car> getCar(){ return car; }
}

public class Car{
    private Optional<Insurance> insurance;
    public Optional<Insurance> getInsurance(){ return insurance; }
}

public class Insurance{
    private String name;
    public String getName(){ return name; }
}

创建Optional对象

// 1. 声明一个空的Optional
Optional<Car> car = Optional.empty();
car.get(); //访问car变量的值会导致 NoSuchElementException

// 2. 依据一个非空值创建Optional
Optional<Car> newcar = Optional.of(car); // 如果car为null，of() 方法会抛出 NullPointerException

// 3.可接受null的Optional
Optional<Car> newcar = Optional.ofNullable(car); //对象即可能是null 也可能是非null，应该使用ofNullable()方法

访问Optional对象

// get()获取值，但可能有异常
String name = "Tom";
Optional<String> opt = Optional.ofNullable(name);
String result = opt.get();

// 验证是否有值
User user = new User("Tom");
Optional<User> opt = Optional.ofNullable(user);
System.out.println(opt.isPresent());
opt.ifPresent( u -> System.out.println(user.getName(), u.getName()));

// 返回默认值
User user = null;
User user2 = new User("Tom");
User result = Optional.ofNullable(user).orElse(user2);

// 返回创建值
User result = Optional.ofNullable(user).orElseGet( () -> user2);

// 返回异常
User result = Optional.ofNullable(user).orElseThrow( () -> new IllegalArgumentException());

转换值

User user = new User("Tom");
String name = Optional.ofNullable(user)
                      .map(u -> u.getName())
                      .orElse("Jack");
assertEquals(name, user.getName());                   

String name2 = Optional.ofNullable(user)
                        .flatMap(u -> u.getName())
                        .orElse("default");
assertEquals(name2, user.getName().get()); //返回值是包装在Optional中

过滤值

User user = new User("[email protected]", "1234");
Optional<User> result = Optional.ofNullable(user)
                                .filter(u -> u.getEmail() != null && u.getEmail().contains("@"));
assertTrue(result.isPresent());

Optional替换null检查

String result = Optional.ofNullable(user)
                      .flatMap(u -> u.getAddress())
                      .flatMap(a -> a.getCountry())
                      .map(c -> c.getIsocode())
                      .orElse("default");

String result = Optional.ofNullable(user)
                      .flatMap(User::getAddress)
                      .flatMap(Address::getCountry)
                      .map(Country::getIsocode)
                      .orElse("default");

增加抛出异常

Optional.ofNullable(comp)
            .map(c->c.getResult())
            .map(r->r.getChampion())
            .map(u->u.getName())
            .orElseThrow(()->new IllegalArgumentException("The value of param comp isn't available."));

检查合法性

public void setName(String name) throws IllegalArgumentException {
    this.name = Optional.ofNullable(name).filter(User::isNameValid)
                        .orElseThrow(()->new IllegalArgumentException("Invalid username."));
}

参考：
https://www.cnblogs.com/zhangboyu/p/7580262.html
http://www.importnew.com/26066.html

小结

Optional 类主要解决了空指针异常（NullPointerException），对我们代码的健壮性有很大帮助

概念

使用Optional

小结

猜你喜欢