Java8 特性笔记(六) Optional（含源码分析）

绝地灬酷狼 2022-03-11 05:01 79阅读 0赞

#### 在任何语言开发中我们都会遇到很多bug，然后在众多bug中，空指针又是出现最多的，每个编程语言都有空指针，只不过有些语言对空指针有了系统处理，例如 kotlin会自动检测空指针的存在并在编写代码的时候就报错，java没有这功能，但是在java8之后 有一个类可以为我们解决空指针的问题，它就是Optional ####

> 我们看源码里面的一段话，就知道optional想干嘛了

A container object which may or may not contain a non-null value.

可以理解optional是一个容器，它在里面帮我们做了非空判断

#### 接下来我们从源码的角度分析Optional里面的具体功能 ####

### 1、empty ###

源码分析：

public static<T> Optional<T> empty() { 
 @SuppressWarnings("unchecked")
 Optional<T> t = (Optional<T>) EMPTY;
 return t;
 }
 /** 创建一个空的Optional，也就是里面什么都没有 只是一个空的容器 */

用法：

Optional<String> emptyOptional = Optional.empty();
 System.out.println(emptyOptional.get());//报错
 System.out.println(emptyOptional.orElse("unkonwn"));//打印unkonwn
 //既然是空的里面就没有数据，就不可能拿到数据

### 2、ofNullable ###

源码分析：  
从源码主注释里面来看，这是在创建一个非空的Optional容器，如果你传入空值，他就会创建一个空的容器，从下面的三目运算符可以看出，如果不是空值，就会调用of方法，of的方法往下翻

/** * Returns an {@code Optional} describing the specified value, if non-null, * otherwise returns an empty {@code Optional}. * * @param <T> the class of the value * @param value the possibly-null value to describe * @return an {@code Optional} with a present value if the specified value * is non-null, otherwise an empty {@code Optional} */
 public static <T> Optional<T> ofNullable(T value) { 
 return value == null ? empty() : of(value);
 }

用法

Optional<String> optional1 = Optional.ofNullable(null);
 Optional<String> optional2 = Optional.ofNullable("hb");
 System.out.println(optional1); //空值不能调用get 返回Optional.empty
 System.out.println(optional2.get()); //打印hb

### 3、of ###

源码分析：  
从源码里面看，这里创建的是一个有内容的容器 Optional，注意不要传空值，注释里面说了，传空值会报错的，所以我们再创建的时候还是调用`ofNullable`这个来创建，你传入空值它就创建空的容器，不是空它就调用`of`

/** * Returns an {@code Optional} with the specified present non-null value. * * @param <T> the class of the value * @param value the value to be present, which must be non-null * @return an {@code Optional} with the value present * @throws NullPointerException if value is null */
 public static <T> Optional<T> of(T value) { 
 return new Optional<>(value);
 }

### 4、get ###

源码分析：  
get其实就是返回里面的值，只不过在源码里面帮你做了判断

/** * If a value is present in this {@code Optional}, returns the value, * otherwise throws {@code NoSuchElementException}. * * @return the non-null value held by this {@code Optional} * @throws NoSuchElementException if there is no value present * * @see Optional#isPresent() */
        public T get() { 
            if (value == null) { 
                throw new NoSuchElementException("No value present");
            }
            return value;
        }

用法就不多说了，上面有例子，直接调用就行 返回值

### 5、orElse ###

源码分析：  
从源码里面来看，这个方法传入一个值，如果容器中有值就返回值，如果没有值则返回我们这里传入的值，这里传入的值一般是提示 如 -1

/** * Return the value if present, otherwise return {@code other}. * * @param other the value to be returned if there is no value present, may * be null * @return the value, if present, otherwise {@code other} */
        public T orElse(T other) { 
            return value != null ? value : other;
        }

用法：

Optional<String> optional1 = Optional.ofNullable(null);
 Optional<String> optional2 = Optional.ofNullable("hb");
 System.out.println(optional1.orElse("里面是空的")); //打印 里面是空的
 System.out.println(optional2.get()); //打印hb

### 6、orElseGet ###

源码分析：  
首先如果值不为空的话和get一样返回值，如果为空就会使用函数式接口，返回函数式接口里面的内容，  
如果不懂什么是函数式接口请看我前面的文章，  
Supplier 不用传参，返回一个T对象， T表示泛型

/** * Return the value if present, otherwise invoke {@code other} and return * the result of that invocation. * * @param other a {@code Supplier} whose result is returned if no value * is present * @return the value if present otherwise the result of {@code other.get()} * @throws NullPointerException if value is not present and {@code other} is * null */
 public T orElseGet(Supplier<? extends T> other) { 
 return value != null ? value : other.get();
 }

用法：  
肯定有人感觉

Optional<String> optional1 = Optional.ofNullable(null);
 Optional<String> optional2 = Optional.ofNullable("hb");
 System.out.println(optional1.orElse("没有内容")); //打印 里面是空的
 System.out.println(optional2.get()); //打印hb
 System.out.println(optional1.orElseGet(()->"数据为空")); //打印 hb
 System.out.println(optional2.orElseGet(()->"数据为空")); //打印 数据为空

### 7、orElseThrow ###

源码分析  
从源码的角度分析我们知道，当Optional中有值的话，就返回该值，没有值的话就抛出一个异常，这个异常是有Supplier函数式接口提供的

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

用法:

Optional<String> stringOptional = Optional.of("hb");
 System.out.println(stringOptional.orElseThrow(CustomException::new));
 
 Optional<String> emptyOptional = Optional.empty();
 System.out.println(emptyOptional.orElseThrow(CustomException::new));
 
 private static class CustomException extends RuntimeException { 
 private static final long serialVersionUID = -4399699891687593264L;
 
 public CustomException() { 
 super("exception");
 }
 
 public CustomException(String message) { 
 super(message);
 }
 }

### 8、filter ###

源码分析：  
在这里我们知道filter这个方法传入一个Predicate的函数式接口，过滤元素，将符合条件的元素重新生成一个Optional对象，否则将会生成一个空的Optional对象  
这里的Predicate函数式接口我在前面的文章有详细的介绍

/** * If a value is present, and the value matches the given predicate, * return an {@code Optional} describing the value, otherwise return an * empty {@code Optional}. * * @param predicate a predicate to apply to the value, if present * @return an {@code Optional} describing the value of this {@code Optional} * if a value is present and the value matches the given predicate, * otherwise an empty {@code Optional} * @throws NullPointerException if the predicate is null */
 public Optional<T> filter(Predicate<? super T> predicate) { 
 Objects.requireNonNull(predicate);
 if (!isPresent())
 return this;
 else
 return predicate.test(value) ? this : empty();
 }

用法:

Optional<String> optionalList = Optional.ofNullable("xioaming");
 System.out.println(optionalList.filter(it->it.length()>5).get()); //打印小明
 System.out.println(optionalList.filter(it->it.length()>10).get()); //异常

### 9 map ###

源码分析  
map这个方法是利用Function进行操作，当其中包含元素，不为空，将元素输入Function函数式接口中，输入一个元素形成另一个并返回，返回类型可以不是Optional类型，源码里可以看到并没有做封装，如果Optional元素为空就会调用empty创建一个空的Optional

public Optional map(Function<? super T, ? extends U> mapper) { 
 Objects.requireNonNull(mapper);
 if (!isPresent())
 return empty();
 else { 
 return Optional.ofNullable(mapper.apply(value));
 }
 }

用法:

Optional<String> stringOptional = Optional.of("xiaoming");
 System.out.println(stringOptional.map(e -> e.toUpperCase()).orElse("fail"));
 //这里是将字符串全部转换成大写，如果不存在则会调用后面的orElse

### 10、flagMap ###

源码分析：  
从flagMap的源码里面看到，我们再调用flatMap的时候 返回的类型必须是Optional这个类型，也就是在返回的随时候给我们做了封装

public Optional flatMap(Function<? super T, Optional> mapper) { 
 Objects.requireNonNull(mapper);
 if (!isPresent())
 return empty();
 else { 
 return Objects.requireNonNull(mapper.apply(value));
 }
 }

用法:

Optional<String> stringOptional = Optional.of("xiaoming");
 System.out.println(stringOptional.flatMap(e -> Optional.of("haha")).orElse("失败"));
 //打印出来的是 haha

### 11、ifPresent ###

源码分析  
这个方法可能是我们以后用的比较多的方法，它在源码里面的解释知道，它表示在Optional里面的值不为空的情况下使用Consumer函数式接口去消费，也就是我们自己想做什么事，如果为空就什么也不做，肯定不会报错，很好的避免了空指针

/** * If a value is present, invoke the specified consumer with the value, * otherwise do nothing. * * @param consumer block to be executed if a value is present * @throws NullPointerException if value is present and {@code consumer} is * null */
 public void ifPresent(Consumer<? super T> consumer) { 
 if (value != null)
 consumer.accept(value);
 }