Java——》Optional用法

一、API介绍 of()

功能：创建Optional实例
注意：创建对象时传入的参数不能为null。如果传入参数为null，则抛出NullPointerException 。

    public static void of() {
        // 创建Optional实例：参数非null
        Optional<String> notNullOptional = Optional.of("xiaoxian");

        // 创建Optional实例：参数为null，抛出 NullPointerException
        try {
            Optional<String> nullOptional = Optional.of(null);
        } catch (NullPointerException e) {
            // 输出：null
            System.out.println("【of()】" + e.getMessage());
            // 输出：java.lang.NullPointerException
            e.printStackTrace();
        }
    }

ofNullable()

功能：创建Optional实例
注意：如果指定的值为null，则返回一个空的Optional。

    public static void ofNullable() {

        // ofNullable()与of()相似，区别在于：ofNullable()是可以接受参数为null的情况。

        // 创建Optional实例：参数非null
        Optional<String> notNullOptional = Optional.ofNullable("xiaoxian");

        // 创建Optional实例：参数为null，不会报错，返回一个空的Optional实例
        Optional<String> nullOptional = Optional.ofNullable(null);
    }

empty()

功能：创建空的Optional实例

    public static void empty() {
        // 创建空的Optional实例
        Optional<String> emptyOptional = Optional.empty();
    }

get()

功能：获取Optional实例值
注意：如果实例值非null，就返回实例值，否则抛出NoSuchElementException

    public static void get() {
        // 获取Optional实例值，如果实例值非null，就返回实例值，否则抛出NoSuchElementException

        // 输出：xiaoxian
        System.out.println("【get()】" + notNullOptional.get());

        try {
            //如果Optional实例值为空，抛出 NoSuchElementException
            // 输出：No value present
            System.out.println("【get()】" + nullOptional.get());
        } catch (NoSuchElementException e) {
            // 输出：java.util.NoSuchElementException
            e.printStackTrace();
        }
    }

isPresent()

功能：检查Optional实例是否包含值。如果值存在返回true，否则返回false

    public static void isPresent() {
        //检查Optional实例是否包含值：如果值存在返回true，否则返回false
        
        // 输出：true
        System.out.println("【isPresent()】" + notNullOptional.isPresent());
        
        // 输出：false
        System.out.println("【isPresent()】" + nullOptional.isPresent());
    }

ifPresent()

功能：检查Optional实例是否有值，如果实例值非null，就执行lambda表达式，否则不处理

    public static void ifPresent() {
        //检查Optional实例是否有值，如果实例值非null，就执行lambda表达式，否则不处理
        notNullOptional.ifPresent(s -> {
            s = s + " love java";
            // 输出：xiaoxian love java
            System.out.println("【ifPresent()】" + s);
        });

        // 通过ifPresent修改的值，再次通过get获取的时候不会改变
        // 输出：xiaoxian
        System.out.println("【ifPresent()】" + notNullOptional.get());
    }

orElse()

功能：检查Optional实例是否有值，如果实例非null，就返回实例值，否则返回指定的其它值。

    public static void orElse() {
        //如果Optional实例值非null，返回Optional的值
        // 输出：xiaoxian
        System.out.println("【orElse()】" + notNullOptional.orElse("There is no value present!"));

        //如果Optional实例值为null，返回传入的值
        // 输出：xiaoxian 666
        System.out.println("【orElse()】" + nullOptional.orElse("xiaoxian 666"));
    }

orElseGet()

功能：检查Optional实例是否有值，如果实例值非null，就返回实例值，否则返回lambda表达式的值。

    public static void orElseGet() {
        // orElseGet与orElse方法类似
        // 区别在于：orElse传入的是默认值，orElseGet可以接收一个lambda表达式生成默认值

        //如果Optional实例值非null，返回Optional的值
        // 输出：xiaoxian
        System.out.println("【orElseGet()】" + notNullOptional.orElseGet(() -> "Default Value"));

        //如果Optional实例值为null，返回lambda表达式的值
        // 输出：Default Value
        System.out.println("【orElseGet()】" + nullOptional.orElseGet(() -> "Default Value"));
    }

orElseThrow()

功能：检查Optional实例是否有值，如果实例值非null，就不做任何处理，否则抛异常Exception。

    public static void orElseThrow() {
        // orElseThrow与orElse方法类似
        // 区别在于：orElse传入的是默认值，orElseThrow会抛出lambda表达式或方法生成的异常

        try {
            //如果Optional实例值非null，不做任何处理，不会报异常
            notNullOptional.orElseThrow(Exception::new);
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            //如果Optional实例值为null，抛异常Exception
            nullOptional.orElseThrow(Exception::new);
        } catch (Throwable e) {
            // 输出: null
            System.out.println("【orElseThrow()】" + e.getMessage());
            e.printStackTrace();
        }
    }

map()

功能：对Optional实例值进行修改
注意：如果Optional实例值非null，就执行map(lambda表达式，任意类型)，返回新的Optional实例，否则返回空Optional。

    public static void map() {
        // 如果Optional实例值非null，执行map(lambda表达式，任意类型)，返回新的Optional实例

        Optional<String> notNullToUpperCase = notNullOptional.map((value) -> value.toUpperCase());

        // 输出：XIAOXIAN
        System.out.println("【map()】" + notNullToUpperCase.orElse("No value found"));

        Optional<Integer> notNullToInteger = notNullOptional.map((value) -> 1);
        // 输出：1
        System.out.println("【map()】" + notNullToInteger.orElse(2));

        // 如果Optional实例值为null，不用执行map()，返回空Optional
        Optional<String> emptyToUpperCase = nullOptional.map((value) -> value.toUpperCase());
        // 输出：No value found
        System.out.println("【map()】" + emptyToUpperCase.orElse("No value found"));
    }

flatMap()

功能：对Optional实例值进行修改
注意：flatMap()与 map()类似，区别在于：传入方法的lambda表达式的返回类型
map()：lambda表达式返回值可以是任意类型，在map函数返回之前会包装为Optional
flatMap：lambda表达式返回值必须是Optionl实例,不会把结果包装为Optional

    public static void flatMap() {
        // flatMap()与 map()类似，区别在于：传入方法的lambda表达式的返回类型
        //      map()：lambda表达式返回值可以是任意类型，在map函数返回之前会包装为Optional
        //      flatMap：lambda表达式返回值必须是Optionl实例,不会把结果包装为Optional

        //如果Optional的值非null，执行flatMap(lambda表达式)，返回Optional类型返回值
        Optional<String> notNullToUpperCase = notNullOptional.flatMap((value) -> Optional.of(value.toUpperCase()));
        // 输出：XIAOXIAN
        System.out.println("【flatMap()】" + notNullToUpperCase.orElse("No value found"));

        //如果Optional的值为null，不用执行flatMap(lambda表达式)，返回空Optional
        Optional<String> optional = nullOptional.flatMap((value) -> Optional.of(value.toUpperCase()));
        // 输出：No value found
        System.out.println("【flatMap()】" + optional.orElse("No value found"));
    }

filter()

功能：判断Option实例有值，并且满足条件
注意：如果有值并且满足条件，就返回该Optional，否则返回空Optional。

    public static void filter() {
        // 如果满足filter条件，则返回该Option实例，否则返回空Optional
        Optional<String> filterTrue = notNullOptional.filter((value) -> value.length() > 6);
        //输出：xiaoxian
        System.out.println("【filter】" + filterTrue.orElse("不滿足filter條件"));

        //如果不满足filter条件，则返回空Optional
        Optional<String> filterFalse = notNullOptional.filter((value) -> value.length() > 10);
        //输出：不满足filter條件
        System.out.println("【filter】" + filterFalse.orElse("不滿足filter條件"));
    }

二、推荐写法 1、如果实例值不为null，就返回值，否则为null

        // 之前写法
        User user1 = userOptional.isPresent() ? userOptional.get() : null;

        // 推荐写法
        User user2 = userOptional.orElse(null);

2、如果实例值不为null，就返回值，否则进行指定 *** 作

        // 之前写法
        User user3 = userOptional.isPresent() ? userOptional.get(): getUser();

        // 推荐写法
        User user4 = userOptional.orElseGet(() -> getUser());

3、如果实例值不为null，就进行指定 *** 作

        // 之前写法
        if (userOptional.isPresent()) {
            System.out.println(userOptional.get());
        }
        // 推荐写法
        userOptional.ifPresent(System.out::println);

        // 之前写法
        if (userOptional.isPresent()) {
            getUser();
        }
        // 推荐写法
        userOptional.ifPresent(e->getUser());

4、如果实例值不为null，就获取实例值，并进行指定 *** 作

        // 之前写法
        List<String> list = null;
        if(userOptional.isPresent()) {
            list = userOptional.get().getCourseList();
        } else {
            list = Collections.emptyList();
        }

        // 推荐写法
        list = userOptional.map(u -> u.getCourseList()).orElse(Collections.emptyList());

        // 之前写法
        getName(new User("xiaoxian"));

        // 推荐写法
        getNameNew(new User("xiaoxian"));

        public static String getName(User user){
            if(user != null) {
                String name = user.getName();
                if(name != null) {
                    return name.toUpperCase();
                } else {
                    return null;
                }
            } else {
                return null;
            }
        }

        public static String getNameNew(User user){
            Optional<User> userOptional = Optional.ofNullable(user);
            return userOptional.map(u -> u.getName())
                    .map(name -> name.toUpperCase())
                    .orElse(null);
        }

三、API示例代码

import java.util.NoSuchElementException;
import java.util.Optional;

public class TestOptional {
    // Optional实例：有值
    public static Optional<String> notNullOptional = Optional.of("xiaoxian");
    // Optional实例：空值
    public static Optional<String> nullOptional = Optional.ofNullable(null);

    public static void main(String args[]) {
        of();
        ofNullable();
        empty();
        get();
        isPresent();
        ifPresent();
        orElse();
        orElseGet();
        orElseThrow();
        map();
        flatMap();
        filter();
    }

    public static void of() {
        // 创建Optional实例：参数非null
        Optional<String> notNullOptional = Optional.of("xiaoxian");

        // 创建Optional实例：参数为null，抛出 NullPointerException
        try {
            Optional<String> nullOptional = Optional.of(null);
        } catch (NullPointerException e) {
            // 输出：null
            System.out.println("【of()】" + e.getMessage());
            // 输出：java.lang.NullPointerException
            e.printStackTrace();
        }
    }

    public static void ofNullable() {

        // ofNullable()与of()相似，区别在于：ofNullable()是可以接受参数为null的情况。

        // 创建Optional实例：参数非null
        Optional<String> notNullOptional = Optional.ofNullable("xiaoxian");

        // 创建Optional实例：参数为null，不会报错，返回一个空的Optional实例
        Optional<String> nullOptional = Optional.ofNullable(null);
    }

    public static void empty() {
        // 创建空的Optional实例
        Optional<String> emptyOptional = Optional.empty();
    }

    public static void get() {
        // 获取Optional实例值，如果Optional实例值非空，就返回值，否则抛出NoSuchElementException

        // 输出：xiaoxian
        System.out.println("【get()】" + notNullOptional.get());

        try {
            //如果Optional实例值为空，抛出 NoSuchElementException
            // 输出：No value present
            System.out.println("【get()】" + nullOptional.get());
        } catch (NoSuchElementException e) {
            // 输出：java.util.NoSuchElementException
            e.printStackTrace();
        }
    }

    public static void isPresent() {
        //检查Optional实例是否包含值：如果值存在返回true，否则返回false

        // 输出：true
        System.out.println("【isPresent()】" + notNullOptional.isPresent());

        // 输出：false
        System.out.println("【isPresent()】" + nullOptional.isPresent());
    }

    public static void ifPresent() {
        //检查Optional实例是否有值，如果实例值非空，就执行lambda表达式，否则不处理
        notNullOptional.ifPresent(s -> {
            s = s + " love java";
            // 输出：xiaoxian love java
            System.out.println("【ifPresent()】" + s);
        });

        // 通过ifPresent修改的值，再次通过get获取的时候不会改变
        // 输出：xiaoxian
        System.out.println("【ifPresent()】" + notNullOptional.get());
    }

    public static void orElse() {
        //如果Optional实例值非null，返回Optional的值
        // 输出：xiaoxian
        System.out.println("【orElse()】" + notNullOptional.orElse("There is no value present!"));

        //如果Optional实例值为null，返回传入的值
        // 输出：xiaoxian 666
        System.out.println("【orElse()】" + nullOptional.orElse("xiaoxian 666"));
    }

    public static void orElseGet() {
        // orElseGet与orElse方法类似
        // 区别在于：orElse传入的是默认值，orElseGet可以接收一个lambda表达式生成默认值

        //如果Optional实例值非null，返回Optional的值
        // 输出：xiaoxian
        System.out.println("【orElseGet()】" + notNullOptional.orElseGet(() -> "Default Value"));

        //如果Optional实例值为null，返回lambda表达式的值
        // 输出：Default Value
        System.out.println("【orElseGet()】" + nullOptional.orElseGet(() -> "Default Value"));
    }

    public static void orElseThrow() {
        // orElseThrow与orElse方法类似
        // 区别在于：orElse传入的是默认值，orElseThrow会抛出lambda表达式或方法生成的异常

        try {
            //如果Optional实例值非null，不做任何处理，不会报异常
            notNullOptional.orElseThrow(Exception::new);
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            //如果Optional实例值为null，抛异常Exception
            nullOptional.orElseThrow(Exception::new);
        } catch (Throwable e) {
            // 输出: null
            System.out.println("【orElseThrow()】" + e.getMessage());
            e.printStackTrace();
        }
    }

    public static void map() {
        // 如果Optional实例值非null，执行map(lambda表达式，任意类型)，返回新的Optional实例

        Optional<String> notNullToUpperCase = notNullOptional.map((value) -> value.toUpperCase());

        // 输出：XIAOXIAN
        System.out.println("【map()】" + notNullToUpperCase.orElse("No value found"));

        Optional<Integer> notNullToInteger = notNullOptional.map((value) -> 1);
        // 输出：1
        System.out.println("【map()】" + notNullToInteger.orElse(2));

        // 如果Optional实例值为null，不用执行map()，返回空Optional
        Optional<String> emptyToUpperCase = nullOptional.map((value) -> value.toUpperCase());
        // 输出：No value found
        System.out.println("【map()】" + emptyToUpperCase.orElse("No value found"));
    }

    public static void flatMap() {
        // flatMap()与 map()类似，区别在于：传入方法的lambda表达式的返回类型
        //      map()：lambda表达式返回值可以是任意类型，在map函数返回之前会包装为Optional
        //      flatMap：lambda表达式返回值必须是Optionl实例,不会把结果包装为Optional

        //如果Optional实例值非null，执行flatMap(lambda表达式)，返回Optional类型返回值
        Optional<String> notNullToUpperCase = notNullOptional.flatMap((value) -> Optional.of(value.toUpperCase()));
        // 输出：XIAOXIAN
        System.out.println("【flatMap()】" + notNullToUpperCase.orElse("No value found"));

        //如果Optional实例值为null，不用执行flatMap(lambda表达式)，返回空Optional
        Optional<String> optional = nullOptional.flatMap((value) -> Optional.of(value.toUpperCase()));
        // 输出：No value found
        System.out.println("【flatMap()】" + optional.orElse("No value found"));
    }

    public static void filter() {
        // 如果满足filter条件，则返回该Option实例，否则返回空Optional
        Optional<String> filterTrue = notNullOptional.filter((value) -> value.length() > 6);
        //输出：xiaoxian
        System.out.println("【filter】" + filterTrue.orElse("不滿足filter條件"));

        //如果不满足filter条件，则返回空Optional
        Optional<String> filterFalse = notNullOptional.filter((value) -> value.length() > 10);
        //输出：不满足filter條件
        System.out.println("【filter】" + filterFalse.orElse("不滿足filter條件"));
    }
}

四、推荐示例代码

import java.util.Collections;
import java.util.List;

public class UseOptional {
    public static User getUser() {
        return new User("xiaoxian");
    }

    public static void main(String[] args) {

        Optional<User> userOptional = Optional.of(new User("xiaoxian"));

        // 之前写法
        User user1 = userOptional.isPresent() ? userOptional.get() : null;

        // 推荐写法
        User user2 = userOptional.orElse(null);

        // 之前写法
        User user3 = userOptional.isPresent() ? userOptional.get() : getUser();
        // 推荐写法
        User user4 = userOptional.orElseGet(() -> getUser());

        // 之前写法
        if (userOptional.isPresent()) {
            System.out.println(userOptional.get());
        }
        // 推荐写法
        userOptional.ifPresent(System.out::println);

        // 之前写法
        if (userOptional.isPresent()) {
            getUser();
        }
        // 推荐写法
        userOptional.ifPresent(e -> getUser());

        // 之前写法
        List<String> list = null;
        if (userOptional.isPresent()) {
            list = userOptional.get().getCourseList();
        } else {
            list = Collections.emptyList();
        }

        // 推荐写法
        list = userOptional.map(u -> u.getCourseList()).orElse(Collections.emptyList());

        // 之前写法
        getName(new User("xiaoxian"));

        // 推荐写法
        getNameNew(new User("xiaoxian"));


    }

    public static String getName(User user) {
        if (user != null) {
            String name = user.getName();
            if (name != null) {
                return name.toUpperCase();
            } else {
                return null;
            }
        } else {
            return null;
        }
    }

    public static String getNameNew(User user) {
        Optional<User> userOptional = Optional.ofNullable(user);
        return userOptional.map(u -> u.getName()).map(name -> name.toUpperCase()).orElse(null);
    }
}

class User {
    public String name;
    public List<String> courseList;

    public User() {
    }

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public List<String> getCourseList() {
        return courseList;
    }
}