Java8之Optional扫盲

亦凉 2022-11-27 00:50 178阅读 0赞

在java8中，引入Optional类，来缓解对每次都需要变量判空的尴尬。Optional在一定程度上，能够减少判空产生的级联深度，运用lambda表达式，也能够在一定程度上简化代码。

--------------------

### 创建一个Optional ###

**1、创建一个可以包含null的Optional**

Optional<String> optional = Optional.ofNullable(null);

**2、创建一个包含null的Optional**

Optional<Object> empty = Optional.empty();

这两个代码的意思是一致的

**3、创建一个不能包含null的Optional**

Optional<String> optional = Optional.of("abc");
    
    
        public static <T> Optional<T> of(T value) {
            return new Optional<>(value);
        }
    
        private Optional(T value) {
            this.value = Objects.requireNonNull(value);
        }
    
        public static <T> T requireNonNull(T obj) {
            if (obj == null)
                throw new NullPointerException();
            return obj;
        }

从代码调用过程来看，of方法不能接收null值，否则会直接抛出空指针异常。

--------------------

### 判断是否null ###

**1、使用isPresent()来判断是否为null**

Optional<String> optional = Optional.of("abc");
            System.out.println(optional.isPresent());//true
    
            Optional<String> empty = Optional.empty();
            System.out.println(empty.isPresent());//false
    
            Optional<String> nullOption = Optional.ofNullable(null);
            System.out.println(nullOption.isPresent());//false

--------------------

### **Option类中的其他方法** ###

这边会涉及到一些Consumer、Supplier、用法，可以先参考我的另外一篇文章[快速理解Consumer、Supplier、Predicate与Function][Consumer_Supplier_Predicate_Function]

**get()，获取值**

public T get() {
            if (value == null) {
                throw new NoSuchElementException("No value present");
            }
            return value;
        }

看出来，get()只能用于不为null的情况下，否则直接抛出NoSuchElementException异常

**ifPresent()，如果不为null，则去进行消费**

public void ifPresent(Consumer<? super T> consumer) {
            if (value != null)
                consumer.accept(value);
        }

**orElseGet()，如果为null，则使用Supplier中供给的值**

public T orElseGet(Supplier<? extends T> other) {
            return value != null ? value : other.get();
        }

**orElse()，如果为null，则直接使用传入的值**

public T orElse(T other) {
            return value != null ? value : other;
        }

**orElseThrow()，如果为null，则抛出某种异常**

public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
            if (value != null) {
                return value;
            } else {
                throw exceptionSupplier.get();
            }
        }

除了以上的方法，还有map、flatmap、filter等，这些方法和Stream中的同名方法类似，只不过Optional中的这些方法返回一个Option，而Stream中返回一个Stream。

--------------------

### 使用Option来改造你的代码 ###

**示例1：输出用户的id**

//改造前
            if (user!=null){
                System.out.println(user.getId());
            }
    
            //改造后
            Optional.ofNullable(user)
                    .map(User::getId)
                    .ifPresent(System.out::println);

**示例2：当用户没有年龄时，使用默认值20岁**

//改造前
            int age1 = 0;
            if (user != null) {
                if (user.getAge() == null) {
                    age1 = 20;
                } else {
                    age1 = user.getAge();
                }
            }
    
            //改造后
            int age2 = Optional.ofNullable(user)
                    .map(User::getId)
                    .orElse(20);

**示例3：当用户的姓名为空时，抛出异常**

//改造前
            if (user != null) {
                String name = user.getName();
                if (name == null) {
                    throw new Exception();
                }
            }
    
            //改造后
            Optional.ofNullable(user)
                    .map(User::getName)
                    .orElseThrow(Exception::new);

**示例4：当用户的年龄大于18岁时，输出一个其大写形式的姓名，当姓名不存在时，输出Unknown**

//改造前
            if (user != null) {
                int age = user.getAge();
                if (age > 18) {
                    String name = user.getName();
                    if (name != null) {
                        System.out.println(name);
                    } else {
                        System.out.println("Unknown");
                    }
                }
            }
    
    
            //改造后
            Optional.ofNullable(user)
                    .filter(u -> u.getAge() > 18)
                    .map(User::getName)
                    .map(String::toUpperCase)
                    .or(() -> Optional.of("Unknown"))
                    .ifPresent(System.out::println);

--------------------

### 总结 ###

看的出来，Optional对多层判空嵌套有奇效。当然，如果只是简单的单层判空，确实没有必要去引入Optional。

[Consumer_Supplier_Predicate_Function]: https://blog.csdn.net/qq_33591903/article/details/102948344?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522159723665919195265906279%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=159723665919195265906279&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_v2~rank_blog_v1-1-102948344.pc_v2_rank_blog_v1&utm_term=Consumer&spm=1018.2118.3001.4187