Optional

static methods:

	Optional.ofNullable();
        Optional.empty();
        Optional.of();		

​ empty():

public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    //返回一个空的Optional
    }
    //等同于 Optional.of(null);

​ of()

// 非null 就继续执行 否则抛异常

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

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

​ ofNullable（）

 public static <T> Optional<T> ofNullable(T value) {
        return value == null ? (Optional<T>) EMPTY
                             : new Optional<>(value);
    }
    //与of 一致的原理 只是少去了抛异常

instance methods

​ get() //非null就get 否则异常

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

isPresent 与 isEmpty

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

ifPresent

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

​ //lambada

 Optional<Integer> integer = Optional.ofNullable(12);
            integer.ifPresent(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) {
                }
            });
            integer.ifPresent((obj)->{
                System.out.println("进入执行操作");
                obj++;
            });
            System.out.println(integer.get()); // 12 

// 根据是否为NULL进行操作

public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
        if (value != null) {
            action.accept(value);
        } else {
            emptyAction.run();
        }
    }

//ifPresentOrElse 实例操作

      var ref = new Object() {
                Integer obj = 25;
            };
            Optional<Object> opt =  Optional.ofNullable(null);
            opt.ifPresentOrElse((i)->{
                System.out.println("不是空");
            },()->{
//                Variable used in lambda expression should be final or effectively final
                ref.obj = 25;
                System.out.println(ref.obj);
            });
            System.out.println(ref.obj);
        }

filter

public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent()) {
            return this;
        } else {
            return predicate.test(value) ? this : empty();
        }
    }
//Predicate 是一个过滤条件  责任链模式 可以and or ！等等

​ //filter进行以上对下进行输入 如果opt是一集合的话 ， 无法进行筛选 ， 只能使用集合本身进行filter

List<Integer> list = Arrays.asList(
                    Integer.parseInt("1"),
                    Integer.parseInt("123"),
                    Integer.parseInt("123123")
            );
            Optional<List<Integer>> opt = Optional.ofNullable(list);

            Stream<Integer> integerStream = list.stream().filter((val) -> {
                return val > 25;
            });
            System.out.println(integerStream.toList().toString());
            //            可以看到filter函数 携带stream流情况下 
//            以上级对下 边里内部属性
//            opt-> filter 的话 value是opt.get() 
//             如果内部进行筛选的话 ，会抛出异常   不允许进行remove  
//            currentModifyException
            opt.filter((var)->{
                System.out.println(var);
                return true;
            });

map()

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

取到map

	                List<String> list = Arrays.asList(
                    new String("zs,123"),
                    new String("ls,123"),
                    new String("ww,123")
            );
            Optional<Object> objectStream = list.stream().findFirst().map(
                    (val)->{

                        return val.split("\\,")[0];
                    }
            );
            Stream<String> stringStream = list.stream().map((arr) -> {
                String result = "";
                for (int i = 0; i <arr.length(); i++) {
//                    arr. 可以看到arr 是无法进行get的 
//                    如果进行筛选 就不一整体为单位 容易失效
                    result += arr.toLowerCase();
                }
                return result;
            });
            System.out.println(stringStream.toList().toString());
            System.out.println(objectStream.get());

flatMap()

//与Map相似 多了个空处理
public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent()) {
            return empty();
        } else {
            @SuppressWarnings("unchecked")
            Optional<U> r = (Optional<U>) mapper.apply(value);
            return Objects.requireNonNull(r);
        }
    }

or（）

//如果当前option value不为空 ， 返回源对象， 否则返回新的对象
public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier) {
        Objects.requireNonNull(supplier);
        if (isPresent()) {
            return this;
        } else {
            @SuppressWarnings("unchecked")
            Optional<T> r = (Optional<T>) supplier.get();
            return Objects.requireNonNull(r);
        }
    }

stream

public Stream<T> stream() {
        if (!isPresent()) {
            return Stream.empty();
        } else {
            return Stream.of(value);
        }
    }

orElse（） // 根据是否为空判断

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

orElseGet（）// 集合Supplier

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

orElseThrow() //是空就跑异常

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

orElseThrow() //是空就抛出自定义异常

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

equals

 public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        return obj instanceof Optional<?> other
                && Objects.equals(value, other.value);
    }