Java8新特性 - Optional 全解

1.Optional的概述

Optional是【java.util】包下的一个工具类；
Optional是【final】修饰的终极类，不可以被继承；
Optional 是一个可以为null的容器类，主要作用是避免常见的【空指针异常】问题 

2.Optional获取对象的三种方式

2.1 方法签名

   1 public static <T> Optional<T> of(T value)
       Optional.of(T) : 直接将值作为of方法的参数;
       此方式不能放入空值，否则会抛出空指针异常，因为该方法的底层调用了 Object.requireNonNull()方法;

  2 public static<T> Optional<T> empty()
      Optional.empty() : 直接返回一个空值对象

  3 public static <T> Optional<T> ofNullable(T value)
     Optional.ofNullable(T) : 如果参数是null,则返回一个空值对象;如果参数不为null,则返回正常的对象

2.2 具体代码

package com.northcastle.J_optional;

import java.util.Optional;

public class Application {
    public static void main(String[] args) {
        
        //1.1 Optional.of(T) 方法
        Optional<String> optinal01 = Optional.of("盖聂");
        //Optional<String> optinal02 = Optional.of(null); // 不可以这样写，这样写会抛出异常

        //1.2 Optional.empty() 方法 ： 获取一个空值对象
        Optional<Object> optionalO3 = Optional.empty();

        //1.3 Optional.ofNullable(T)
        Optional<String> optional04 = Optional.ofNullable("小庄");
        Optional<String> optional05 = Optional.ofNullable(null);
    }
}

3.Optional的常用方法介绍

3.1 get()

3.1.1 方法签名

public T get() :
     返回Optional对象的值；
     如果没有值，则抛出异常 NoSuchElementException。

3.1.2 案例代码

package com.northcastle.J_optional;

import java.util.Optional;

public class OptionalTestGet {
    public static void main(String[] args) {
        // 1.存在值
        Optional<String> optionalGet = Optional.ofNullable("盖聂");
        String s = optionalGet.get();
        System.out.println("s = "+s);
        System.out.println("============================");

        // 2.空值
        Optional<Object> optionalGet02 = Optional.ofNullable(null);
        Object o = optionalGet02.get(); // 这里会抛出异常
        System.out.println("o = "+o);

    }
}

3.1.3 运行结果

3.2 isPresent()

3.2.1 方法签名

 public boolean isPresent() ： 返回布尔值，
        如果值不为空，返回true;
        如果值为空，返回false。

【此方法与get()方法配合使用，避免空值时抛出异常】

3.2.2 案例代码

package com.northcastle.J_optional;

import java.util.Optional;

public class OptionalTestIsPresent {
    public static void main(String[] args) {
        /**
         * isPresent() 和 get() 方法配合使用
         */
        // 1.存在值
        Optional<String> optionalGet = Optional.ofNullable("盖聂");
        if (optionalGet.isPresent()){
            String s = optionalGet.get();
            System.out.println("s = "+s);
        }else{
            System.out.println("optionalGet 对象中没有值");
        }

        System.out.println("============================");

        // 2.空值
        Optional<Object> optionalGet02 = Optional.ofNullable(null);
        if (optionalGet02.isPresent()){
            Object o = optionalGet02.get(); // 这里会抛出异常
            System.out.println("o = "+o);
        }else{
            System.out.println("optionalGet02 中没有值！");
        }
    }
}

3.2.3 运行结果

3.3 ifPresent()

3.3.1 方法签名

 public void ifPresent(Consumer<? super T> consumer) :
      如果值不为空，则执行参数中逻辑；【且Consumer中传入的参数就是optional对象中的值】
      否则不进行任何操作。

3.3.2 案例代码

package com.northcastle.J_optional;

import java.util.Optional;

public class OptionalTestIfPresent {
    public static void main(String[] args) {

        // 1.存在值
        Optional<String> optionalGet = Optional.ofNullable("盖聂");
        optionalGet.ifPresent(s ->{
            System.out.println("s = "+s); // 参数s就是 “盖聂”
            System.out.println("=== optionalGet 中存在值 ： 【"+optionalGet.get()+"】===");
        });
        System.out.println("===========");
        //2.不存在值
        Optional<Object> empty = Optional.empty();
        empty.ifPresent(o ->{
            System.out.println("empty 中存在值"); // 这里是不会执行的
        });
    }
}

3.3.3 运行结果

3.4 filter

3.4.1 方法签名

public Optional<T> filter(Predicate<? super T> predicate) :
       如果Optional中的对象值为空，则返回当前Optional对象，即一个空对象；
       如果Optional对象中的值满足Predicate的条件，则返回当前对象；
       如果Optional对象中的值不满足Predicate的条件，则返回empty()一个空对象。

3.4.2 案例代码

package com.northcastle.J_optional;

import java.util.Optional;

public class OptionalTestFilter {
    public static void main(String[] args) {
        //0.准备一个Optional对象
        Optional<String> optionalGet = Optional.ofNullable("盖聂");
        //1.满足条件 ： 返回当前Optional对象
        Optional<String> optional01 = optionalGet.filter(s -> s.length() > 1);
        System.out.println(optional01);
        System.out.println("=========");
        //2.不满足条件 ： 返回empty() 空对象
        Optional<String> optional02 = optionalGet.filter(s -> s.length() > 5);
        System.out.println(optional02);
    }
}

3.4.3 运行结果

3.5 map

3.5.1 方法签名

 public<U> Optional<U> map(Function<? super T, ? extends U> mapper) :
       如果Optional中的对象值为空，则返回empty(),即一个空对象；
       如果Optional中的对象值不为空，则返回Function处理后的值（已经自动封装为Optional对象）。

3.5.2 案例代码

package com.northcastle.J_optional;

import java.util.Optional;

public class OptionalTestMap {
    public static void main(String[] args) {
        // 1.存在值
        Optional<String> optionalGet = Optional.ofNullable("盖聂");
        Optional<String> optional01 = optionalGet.map(s -> "perfix_" + s);
        System.out.println(optional01);
        System.out.println("============================");

        // 2.空值
        Optional<String> optionalGet02 = Optional.ofNullable(null);
        Optional<String> optional02 = optionalGet02.map(s -> "perfix02-" + s);
        System.out.println(optional02);
    }
}

3.5.3 运行结果

3.6 flatMap

3.6.1 方法签名

 public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) :
       如果Optional中的对象值为空，则返回empty(),即一个空对象；
       如果Optional中的对象值不为空，则返回Function处理后的值（需要手动封装为Optional对象）。

3.6.2 案例代码

package com.northcastle.J_optional;

import java.util.Optional;

public class OptionalTestFlatMap {
    public static void main(String[] args) {
        // 1.存在值
        Optional<String> optionalGet = Optional.ofNullable("盖聂");
        Optional<String> optional01 = optionalGet.flatMap(s -> Optional.ofNullable("perfix_" + s)); // 手动将值转换为Optional
        System.out.println(optional01);
        System.out.println("============================");

        // 2.空值
        Optional<String> optionalGet02 = Optional.ofNullable(null);
        Optional<String> optional02 = optionalGet02.flatMap(s -> Optional.ofNullable("perfix02-" + s)); // 手动将值转换为Optional
        System.out.println(optional02);
    }
}

3.6.3 运行结果

3.7 orElse

3.7.1 方法签名

 public T orElse(T other) ：
      如果Optional中的对象值不为空，则返回原来的值；
      如果Optional中的对象值为空，则返回参数中的值。

3.7.2 案例代码

package com.northcastle.J_optional;

import java.util.Optional;

public class OptionalTestOrElse {
    public static void main(String[] args) {

        // 1.存在值 : 仍返回原来的值
        Optional<String> optionalGet = Optional.ofNullable("盖聂");
        String s01 = optionalGet.orElse("大家好");
        System.out.println("s01 = "+s01);
        System.out.println("============================");

        // 2.空值 ： 返回参数中的值
        Optional<String> optionalGet02 = Optional.ofNullable(null);
        String s02 = optionalGet02.orElse("你好");
        System.out.println("s02 = "+s02);

    }
}

3.7.3 运行结果

3.8 orElseGet

可以看作是 对 orElse方法的一种补充

3.8.1 方法签名

 public T orElseGet(Supplier<? extends T> other) ：
       如果Optional中的对象值不为空，则返回原来的值；
       如果Optional中的对象值为空，则返回参数中Supplier自定义逻辑的返回值。

3.8.2 案例代码

package com.northcastle.J_optional;

import java.util.Optional;

public class OptionalTestOrElseGet {
    public static void main(String[] args) {
        // 1.存在值 : 仍返回原来的值
        Optional<String> optionalGet = Optional.ofNullable("盖聂");
        String s01 = optionalGet.orElseGet(() -> "大家好"); // 参数是 Supplier 类型的对象，可以是Lambda表达式
        System.out.println("s01 = "+s01);
        System.out.println("============================");

        // 2.空值 ： 返回参数中的值
        Optional<String> optionalGet02 = Optional.ofNullable(null);
        String s02 = optionalGet02.orElseGet(() -> "你好"); // 参数是 Supplier 类型的对象，可以是Lambda表达式
        System.out.println("s02 = "+s02);
    }
}

3.8.3 运行结果

3.9 orElseThrow

3.9.1 方法签名

 public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X ：
       如果Optional中的对象值不为空，则返回原来的值；
       如果Optional中的对象值为空，则抛出异常 ： 参数Supplier可以是某个异常的构造器，如：IllegalStateException::new

3.9.2 案例代码

package com.northcastle.J_optional;

import java.util.Optional;

public class OptionalTestOrElseThrow {
    public static void main(String[] args) {
        // 1.存在值 : 仍返回原来的值
        Optional<String> optionalGet = Optional.ofNullable("盖聂");
        String s01 = optionalGet.orElseThrow(NullPointerException::new); // 参数是 Supplier 类型的对象，需要返回一个异常对象
        System.out.println("s01 = "+s01);
        System.out.println("============================");

        // 2.空值 ： 返回参数中的值
        Optional<String> optionalGet02 = Optional.ofNullable(null);
        String s02 = optionalGet02.orElseThrow(NullPointerException::new); // 参数是 Supplier 类型的对象，需要返回一个异常对象
        System.out.println("s02 = "+s02);
    }
}

3.9.3 运行结果

4.完成

Congratulations!
You are one step closer to success!