JAVASE学习笔记（十五）（Optional的应用）

• jdk1.8新特性`Optional`的应用
• • 概述
  • 作用
  • 源码分析
  • • 方法
    • • 1. `isPresent`:判断查询的类对象是否存在
      • 2. ` orElseThrow()`: 相当于` if ... throws`
      • 3. `orElse()`:相当于 `if + new (赋值默认值)`
      • 4. `oElseGet()`:相当于 `if + 加逻辑处理`
    • 应用 ：`isPresent`和`orElse()`
    • 总结
    • • `of` 和`offNullAble`区别
      • `Optional`中`filter` ,`map`,`flatmap`的认识
      • • 注意：`filter` ,`map`,`flatmap`都属于`java.util.Stream`的中间方法。但此处的`filter`方法与之前的`stream`流中间方法无关

> 学相伴学习笔记

Google Guava项目曾提出用Optional类来包装对象从而解决NullPointerException。受此影响，JDK8的类中也引入了Optional类，在新版的SpringData Jpa和Spring Redis Data中都已实现了对该方法的支持。

• 简化程序逻辑
• 可以修复程序代码中的逻辑判断的问题

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 {
    
    private static final Optional EMPTY = new Optional<>();

    
    private final T value;

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

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

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

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

    
    public static  Optional 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 consumer) {
        if (value != null)
            consumer.accept(value);
    }

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

    
    public Optional map(Function mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent())
            return empty();
        else {
            return Optional.ofNullable(mapper.apply(value));
        }
    }

    
    public Optional flatMap(Function> 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 other) {
        return value != null ? value : other.get();
    }

    
    public  T orElseThrow(Supplier 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";
    }
}

User user = null;
Optional optional = Optional.ofNullable(user);
if(  !  optional.isPresent()){
	throw  new RuntimeException("用户找不到!!!");
}

  public static User getUser(Integer userId){
        User user = null;
        user = Optional.ofNullable(user)
                .orElseThrow(()->new RuntimeException("用户找不到!!!"));//简化 简化 if + throws / if/else
        return user;
    }

public static User getUser(Integer userId)  {
    User user = null;
    user = Optional.ofNullable(user).orElse(new User());
    return user;
}

user = Optional.ofNullable(user).orElseGet(()->{
    User user1 = new User();
    // 增加各种处理和逻辑
    return user1;
});

User user = new User();
user.setNickname(Optional.ofNullable(user.getNickname()).orElse("学生"));
user.setPassword(Optional.ofNullable(user.getPassword()).orElse("123456"));

@Test
    public void m1(){
        Optional fullName2 = Optional.ofNullable(null);
        Optional fullName = Optional.of(null);
    }

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

public static  T requireNonNull(T obj) {
    if (obj == null)
        throw new NullPointerException(); // 如果value是null，就出现空指针异常
    return obj;
}

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

List users = null;
        users = Optional.ofNullable(users) // 1： 创建一Optional并给Optional的value赋值null
                .filter((u) -> u.get(0).getId().equals(1))// 2: 调用的Optional中filter内部出现空异常，不报错，赋值空的Optional对象
                .orElse(new ArrayList<>()); // 3: 如果前面代码是空对象，则初始化集合
        System.out.println(users);