Optional 接口初使用

红太狼 2022-04-08 13:50 192阅读 0赞

## Optional 接口 ##

**源码**

package java.util;
 
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
 
 public final class Optional<T> {
 
 private static final Optional<?> EMPTY = new Optional<>();
 
 private final T value;
 
 private Optional() {
 this.value = null;
 }
 
 public static<T> Optional<T> empty() {
 @SuppressWarnings("unchecked")
 Optional<T> t = (Optional<T>) EMPTY;
 return t;
 }
 
 private Optional(T value) {
 this.value = Objects.requireNonNull(value);
 }
 
 public static <T> Optional<T> of(T value) {
 return new Optional<>(value);
 }
 
 public static <T> Optional<T> ofNullable(T value) {
 return value == null ? empty() : of(value);
 }
 
 public T get() {
 if (value == null) {
 throw new NoSuchElementException("No value present");
 }
 return value;
 }
 
 public boolean isPresent() {
 return value != null;
 }
 
 public void ifPresent(Consumer<? super T> consumer) {
 if (value != null)
 consumer.accept(value);
 }
 
 public Optional<T> filter(Predicate<? super T> predicate) {
 Objects.requireNonNull(predicate);
 if (!isPresent())
 return this;
 else
 return predicate.test(value) ? this : empty();
 }
 
 public Optional map(Function<? super T, ? extends U> mapper) {
 Objects.requireNonNull(mapper);
 if (!isPresent())
 return empty();
 else {
 return Optional.ofNullable(mapper.apply(value));
 }
 }
 
 public Optional flatMap(Function<? super T, Optional> mapper) {
 Objects.requireNonNull(mapper);
 if (!isPresent())
 return empty();
 else {
 return Objects.requireNonNull(mapper.apply(value));
 }
 }
 
 public T orElse(T other) {
 return value != null ? value : other;
 }
 
 public T orElseGet(Supplier<? extends T> other) {
 return value != null ? value : other.get();
 }
 
 public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
 if (value != null) {
 return value;
 } else {
 throw exceptionSupplier.get();
 }
 }
 
 @Override
 public boolean equals(Object obj) {
 if (this == obj) {
 return true;
 }
 
 if (!(obj instanceof Optional)) {
 return false;
 }
 
 Optional<?> other = (Optional<?>) obj;
 return Objects.equals(value, other.value);
 }
 
 @Override
 public int hashCode() {
 return Objects.hashCode(value);
 }
 
 @Override
 public String toString() {
 return value != null
 ? String.format("Optional[%s]", value)
 : "Optional.empty";
 }
 }

有时候看看源码也是一种享受啊，学习源码的这种编码方式，让我受益匪浅。

接下来，说说 Optional 接口的方法：

**构造方法**

构造一个 value 属性为 null 的 Optional 实例

private Optional() {
            this.value = null;
    }

构造一个 value 属性不为 null 的 Optional 实例，如果传递过来的 value 参数为 null 会抛出 NullPointerException 异常。

private Optional(T value) {
            this.value = Objects.requireNonNull(value);
    }

Objects.requireNonNull() 源码：

public static <T> T requireNonNull(T obj) {
 if (obj == null)
 throw new NullPointerException();
 return obj;
 }

两个构造方法都是 private 等级的访问权限，所有我们不能直接使用 new 关键字创建 Optional 实例。

**of() 方法**

of() 方法内部调用有参构造方法创建一个 Optional 实例。  
因为 of() 方法在内部调用了有参构造方法，所以当 value 参数为 null 时，of() 方法会抛出 NullPointerException 异常，所以说 of() 方法会创建一个 value 属性不为 null 的Optional 实例（创建成功的基础上）。

public static <T> Optional<T> of(T value) {
 return new Optional<>(value);
 }

测试：

User.java:

package entity;
    
    public class User {
    
        // 用户默认名字
        public static final String  DEFAULT_NAME = "Kaven";
        // 用户默认年龄
        public static final int DEFAULT_AGE = 20;
        // 用户的年龄
        private int age;
        // 用户的名字
        private String name;
    
        public User(){}
    
        public User(int age , String name){
            this.age = age;
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public boolean equals(Object obj) {
            if(obj == null) return false;
            else{
                if(obj instanceof User){
                    User user = (User) obj;
                    if(this.name.equals((user).name) && this.age == user.age) return true;
                    else return false;
                }
                else return false;
            }
        }
    }

testOptional.java:

package test;
 
 import entity.User;
 
 import java.util.Optional;
 
 public class testOptional {
 
 public static void main(String[] args){
 
 Optional<User> optional = Optional.of(new User()); // 正常
 Optional<User> optional1 = Optional.of(null); // 抛出空指针异常
 }
 }

**empty() 方法**

EMPTY 属性是一个 value 属性为 null 的 Optional 实例，为什么需要 EMPTY 属性呢？以我的理解，EMPTY 属性相当于代替了所有的 value 属性为 null 的 Optional 实例，如果每次创建一个 value 属性为 null 的 Optional 实例，都要调用 Optional 无参构造方法去申请内存创建一个 Optional 实例的话，还不如使用唯一一个 value 属性为 null 的 Optional 实例来代替，这样无论是在时间或者空间上来说都是划得来的，所以 EMPTY 是有价值的。

private static final Optional<?> EMPTY = new Optional<>();

empty() 方法就是返回了 EMPTY 属性，所以无论调用多少次 empty() 方法，返回都是一样的，返回唯一一个 value 属性为 null 的 Optional 实例-EMPTY 属性。

public static<T> Optional<T> empty() {
 @SuppressWarnings("unchecked")
 Optional<T> t = (Optional<T>) EMPTY;
 return t;
 }

测试：

Optional<User> optional = Optional.empty();
 Optional<User> optional1 = Optional.empty();
 System.out.println(optional == optional1);

输出：`true`

**ofNullAble() 方法**

看源码应该很容易理解，就是当传递过来的 value 参数为 null 时，调用 empty()，value 参数不为 null 时，调用 of() 方法。  
也就是说可以创建任何形式的 Optional 实例，无论 value 属性是不是为 null，都可以创建成功。

public static <T> Optional<T> ofNullable(T value) {
 return value == null ? empty() : of(value);
 }

测试：

Optional<User> optional = Optional.ofNullable(new User()); // 正常
 Optional<User> optional1 = Optional.ofNullable(null); // 正常

**get() 方法**

就是返回 Optional 实例的 value 属性。

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

测试：

Optional<User> optional = Optional.of(new User(20 ,"Kaven"));
 User user = optional.get();
 System.out.println(user.getAge());
 System.out.println(user.getName());

输出：

20
    Kaven

**isPresent() 方法**

如果 Optional 实例的 value 属性为 null ，返回 false，否则返回 true。  
所以就是用来判断 Optional 实例的 value 属性是否为 null 的。

public boolean isPresent() {
            return value != null;
    }

**ifPresent() 方法**

参数是一个 Consumer 实例，在 [Consumer 接口 、 Predicate 接口初使用][Consumer _ _ Predicate] 这篇博客中我说过 ，我认为 Consumer 接口的主要作用是用来修改传递过来的参数的。所以我认为 ifPresent() 方法主要是用来修改 Optional 实例的 value 属性的。

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

测试：

Optional<User> optional = Optional.of(new User(20 ,"Kaven"));
 Consumer<User> consumer = user -> {
 user.setAge(21);
 };
 optional.ifPresent(consumer);
 User user = optional.get();
 System.out.println(user.getAge());
 System.out.println(user.getName());

输出：

21
    Kaven

**filter() 方法**

从源码中可以看出来，filter() 方法的参数是一个 Predicate 实例，所以以我的理解，可以先从方法的函数名开始，filter - 过滤，如 web 开发的过滤器，是不是有点熟悉的感觉，所以我觉得 filter() 方法也是起到过滤的作用，如果不匹配 Predicate 实例的 test() 方法的 Optional 实例会返回 EMPTY，也就是调用 empty()，否则返回本身；当然如果这个 Optional 实例本身就是一个 EMPTY(value 为 null,或者说 isPresent() = false)，也返回本身。

public Optional<T> filter(Predicate<? super T> predicate) {
 Objects.requireNonNull(predicate);
 if (!isPresent())
 return this;
 else
 return predicate.test(value) ? this : empty();
 }

测试：

Optional<User> optional = Optional.of(new User(20 ,"Kaven-1"));
 Predicate<User> predicate1 = user -> {
 return user.getName().equalsIgnoreCase("Kaven");
 };
 Predicate<User> predicate2 = user -> {
 return user.getName().equalsIgnoreCase("Kaven-1");
 };
 Optional<User> optional1 = optional.filter(predicate1);
 System.out.println(optional1);
 Optional<User> optional2 = optional.filter(predicate2);
 System.out.println(optional2.get().getName());

输出：

Optional.empty // 重写了 toString()
    Kaven-1

**map() 方法**

map() 方法，方法名让我想起了 mybatis 的映射文件 Mapper.xml，其实这个方法的作用我觉得也是映射，把 `Optional<T>` 实例映射成 `Optional` 实例。

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

测试：  
Admin.java:

package entity;
    
    public class Admin extends User{
    
        // 管理员数量
        private static int Admin_Number = 0;
        // 管理员 id，为了简单管理员 id  就为当前管理员数量值
        private int id;
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public static int adminNumAdd(){
            return ++Admin_Number;
        }
    }

我们通过 map() 方法，把 `Optional<User>` 实例映射成 `Optional<Admin>`。

Function<User , Admin> function = user ->{
 Admin admin = new Admin();
 admin.setAge(user.getAge());
 admin.setName(user.getName());
 admin.setId(Admin.adminNumAdd());
 return admin;
 };
 
 User user = new User(20 , "Kaven");
 Optional<User> optional = Optional.of(user);
 Optional<Admin> optionalAdmin = optional.map(function);
 Admin admin = optionalAdmin.get();
 System.out.println(admin.getAge());
 System.out.println(admin.getName());
 System.out.println(admin.getId());

输出：

20
    Kaven
    1

**flatMap() 方法**

和 map() 方法没有什么差别，都是把 `Optional<T>` 实例映射成 `Optional` 实例，只不过 flatMap() 方法是通过 Function 实例更加直接的映射成 `Optional` ，而 map() 方法是先映射成 U 实例再调用 ofNullable() 方法创建 `Optional` 实例，单词 flat 也有直接的意思。

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

测试：  
代码差不多

Function<User , Optional<Admin>> function = user ->{
 Admin admin = new Admin();
 admin.setAge(user.getAge());
 admin.setName(user.getName());
 admin.setId(Admin.adminNumAdd());
 Optional<Admin> optionalAdmin = Optional.of(admin);
 return optionalAdmin;
 };
 
 User user = new User(20 , "Kaven");
 Optional<User> optional = Optional.of(user);
 Optional<Admin> optionalAdmin = optional.flatMap(function);
 Admin admin = optionalAdmin.get();
 System.out.println(admin.getAge());
 System.out.println(admin.getName());
 System.out.println(admin.getId());

输出：

20
    Kaven
    1

**orElse()**

看源代码可以看出来，如果 Optional 实例的 value 属性为 null，就返回 other 参数，否则就返回该 Optional 实例的 value 属性。  
在我看来，就是选择值的优先级问题，总是会优先选择当前这个 Optional 实例的 value 属性，只有当这个 Optional 实例的 value 属性为 null 时，才选择其他的值。

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

测试：

User user = new User(20 , "Kaven");
 Optional<User> optional = Optional.ofNullable(null);
 User user_test = optional.orElse(user);
 System.out.println(user_test.getAge());
 System.out.println(user_test.getName());
 
 Optional<User> optional_test = Optional.ofNullable(new User(21 ,"Wang"));
 user_test = optional_test.orElse(user);
 System.out.println(user_test.getAge());
 System.out.println(user_test.getName());

输出：

20
    Kaven
    21
    Wang

**orElseGet() 、orElseThrow()**

orElseGet() 源码：

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

orElseThrow() 源码：

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

看源码应该也很容易理解，和 orElse() 相对比理解就好了，我就不测试了。

**equals()、hashCode()、toString()**

重写 Object 类的方法，自己看看源码就行了，不是重点。

要是有说的不对的地方，请指正，万分感谢。

[Consumer _ _ Predicate]: https://blog.csdn.net/qq_37960603/article/details/85054409