Optional

前言

我的使用

package yimeng;import com.ruoyi.RuoYiApplication;
import com.ruoyi.common.core.domain.entity.SysUser;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.*;@SpringBootTest(classes = RuoYiApplication.class)
public class MyTest2 {@Testpublic void testOptional() {List<SysUser> list=new ArrayList<>();SysUser sysUser1=new SysUser(1L,"张三");SysUser sysUser2=new SysUser(1L,"李四");SysUser sysUser3=new SysUser(3L,"王五");list.add(sysUser1);list.add(sysUser2);list.add(sysUser3);Optional<SysUser> optionalSysUser = list.stream().filter((item) -> item.getUserId().compareTo(1L) == 0L).findFirst();SysUser sysUser = optionalSysUser.get();System.out.println(sysUser);//打印了“张三”这个用户}
}

雨泽的使用

package yimeng;import com.ruoyi.RuoYiApplication;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.system.mapper.SysUserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;@SpringBootTest(classes = RuoYiApplication.class)
public class MyTest2 {@Resourceprivate SysUserMapper sysUserMapper;@Testpublic void testOptional2() {SysUser sysUser = sysUserMapper.selectUserById(1L);String s = Optional.ofNullable(sysUser).map(SysUser::getUserName).orElseThrow(() -> new RuntimeException("id是1L的用户为null"));System.out.println(s);SysUser sysUser1 = sysUserMapper.selectUserById(100L);Optional.ofNullable(sysUser1).map(SysUser::getUserName).orElseThrow(() -> new RuntimeException("id是100L的用户为null或者名字为null"));}
}

结果：

这里不知道他有没有走map方法。

但是通过看源码可以知道。其实他是走了map方法的，但是为什么没有抛出空指针异常呢？你null.map()了。

因为他内部把null转换了一下，你Optional.ofNullable(sysUser)返回值不是null了。所以调用map方法不会出现空指针异常。如果sysUser是空，相当于是返回一个private static final Optional<?> EMPTY = new Optional<>();的东西。

然后用这个东西去调用map方法，map方法也是先看你是不是空对应的Optional，看到是调用者是空对应的Optional，也返回一个private static final Optional<?> EMPTY = new Optional<>();，不会去执行真正map()方法中的lambda表达式的，所以看起来像是跳过了map中的逻辑直接执行了orElseThrow方法。

探测：

探测：

ofNullable()参数为null不抛出空指针异常的原因：

filter()参数为null抛出空指针异常的原因：

API详细介绍

Optional 就相当于是一个对象容器。

初始化方法

of(T t)

功能：创建Optional实例

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

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

探测：

探测：

探测：

ofNullable(T t)

功能：创建Optional实例

注意：如果指定的值为null，则返回一个空的Optional。

@Test
public void test(){// ofNullable()与of()相似，区别在于：ofNullable()是可以接受参数为null的情况。// 创建Optional实例：参数非nullOptional<String> notNullOptional = Optional.ofNullable("xiaoxian");// 创建Optional实例：参数为null，不会报错，返回一个空的Optional实例Optional<String> nullOptional = Optional.ofNullable(null);
}

empty()

功能：创建空的Optional实例

    @Testpublic void test(){Optional<String> emptyOptional = Optional.empty();System.out.println(emptyOptional);}

获取

get()

    @Testpublic void test(){Optional<String> notNullOptional = Optional.ofNullable("xiaoxian");System.out.println(notNullOptional.get());Optional<String> emptyOptional = Optional.empty();System.out.println(emptyOptional.get());}

get()：获取optional容器中的对象，当optional 容器为空时报错。返回值为容器中那个对象的类型。

探测：

因为get方法，返回的是Optional对象声明时的那个泛型，不是返回一个Optional对象，所以get()后无法使用Optional的orElseThrow方法。

判断

isPresent()

isPresent()：判断optional是否为空，如果空则返回false，否则返回true

@Test
public void test(){// 创建Optional实例：参数非nullOptional<String> notNullOptional = Optional.ofNullable("xiaoxian");// 创建Optional实例：参数为null，不会报错，返回一个空的Optional实例Optional<String> nullOptional = Optional.ofNullable(null);// 输出：trueSystem.out.println("【isPresent()】" + notNullOptional.isPresent());// 输出：falseSystem.out.println("【isPresent()】" + nullOptional.isPresent());
}

ifPresent(Consumer consumer)

ifPresent(Consumer c)：如果optional不为空，则将optional中的对象传给Comsumer函数，去执行对应的方法。如果为空，不执行什么操作。ifPresent方法的返回是void，所以也不会返回什么东西。

@Test
public void test(){// 创建Optional实例：参数非nullOptional<String> notNullOptional = Optional.ofNullable("xiaoxian");//如果实例值非null，就执行lambda表达式，否则不处理notNullOptional.ifPresent(s -> {s = s + " love java";// 输出：xiaoxian love javaSystem.out.println(s);});
}

Else相关

orElse()和orElseGet()

我们在初始化 Optional 对象的时候，有时候需要一个默认值，这时orElse() 和 orElseGet() 方法就派上用场了（类似三目运算符）。

orElse()功能：检查Optional容器中的对象是否是null，如果非null，就返回这个对象。否则返回你自己指定的其它值。

@Test
public void test(){String name = Optional.ofNullable("张三").orElse("沉默王二");System.out.println(name); // 输出：张三String nullName = null;String name1 = Optional.ofNullable(nullName).orElse("沉默王二");System.out.println(name1); // 输出：沉默王二
}

注意：是返回orElse方法不管，调用它的Optional是不是为空的容器，都会返回它声明的泛型的对象。不是要以为Optional.ofNullable(“张三”).orElse(“沉默王二”);返回还是Optional对象哈。看清楚上面的例子返回的是一个String，不是一个Optional对象哈。

orElseGet()功能：orElseGet() 方法与 orElse() 方法类似，但参数类型不同。orElseGet()方法的功能是，如果 Optional 容器中的对象为 null，则执行参数中的lambda表达式的方法。

@Test
public void test(){Optional<String> notNullOptional = Optional.ofNullable("xiaoxian");Optional<String> nullOptional = Optional.ofNullable(null);// orElseGet与orElse方法类似// 区别在于：orElse传入的是默认值，orElseGet可以接收一个lambda表达式生成默认值//如果Optional实例值非null，返回Optional的值// 输出：xiaoxianSystem.out.println("【orElseGet()】" + notNullOptional.orElseGet(() -> "Default Value"));//如果Optional实例值为null，返回lambda表达式的值// 输出：Default ValueSystem.out.println("【orElseGet()】" + nullOptional.orElseGet(() -> "Default Value"));
}

从输出结果以及代码的形式上来看，这两个方法极其相似，这不免引起我们的怀疑，Java 类库的设计者有必要这样做吗？

假设现在有这样一个获取默认值的方法，很传统的方式

public static String getDefaultValue() {System.out.println("getDefaultValue");return "沉默王二";
}

然后，通过 orElse() 方法和 orElseGet() 方法分别调用 getDefaultValue() 方法返回默认值

public static void main(String[] args) {String name = null;System.out.println("orElse");String name2 = Optional.ofNullable(name).orElse(getDefaultValue());System.out.println("orElseGet");String name3 = Optional.ofNullable(name).orElseGet(Demo::getDefaultValue);
}

注：类名 :: 方法名是 Java 8 引入的语法，方法名后面是没有 () 的，表明该方法并不一定会被调用

输出结果如下所示：

orElse
getDefaultValueorElseGet
getDefaultValue

输出结果是相似的，没什么太大的不同，这是在 Optional 对象的值为 null 的情况下。假如 Optional 对象的值不为 null 呢？

public static void main(String[] args) {String name = "沉默王三";System.out.println("orElse");String name2 = Optional.ofNullable(name).orElse(getDefaultValue());System.out.println("orElseGet");String name3 = Optional.ofNullable(name).orElseGet(OrElseOptionalDemo::getDefaultValue);
}

输出结果如下所示：

orElse
getDefaultValue
orElseGet

在Optional容器中的对象不是null时，orElseGet() 并没有去调用 getDefaultValue()方法，而orElse方法还是会去调用的，只是返回值没有被使用而已。所以orElseGet方法的性能更佳。

直观从语义上来看，get() 方法才是最正宗的获取 Optional 对象值的方法，但很遗憾，该方法是有缺陷的，因为假如 Optional 容器中的值为 null，该方法会抛出 NoSuchElementException 异常。这完全与我们使用 Optional 类的初衷相悖。我们使用 Optional 其实就是为了防止异常。主要是防止空指针异常。如果是空的话，会把null转换为对应的Optional，所以不会出现空指针异常，你使用Optional的get方法，如果Option容器中的对象为null，就会抛出NoSuchElementException 异常，虽然这个不是空指针异常，但是也是异常，所以不建议使用Optional的get方法。

orElseThrow()

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

@Test
public void test(){Optional<String> notNullOptional = Optional.ofNullable("xiaoxian");Optional<String> nullOptional = Optional.ofNullable(null);// orElseThrow与orElse方法类似// 区别在于：orElse传入的是默认值，orElseThrow会抛出他参数中的lambda表达式或方法生成的异常try {//如果Optional实例值非null，不做任何处理，不会执行orElseThrow()内的方法。notNullOptional.orElseThrow(Exception::new);} catch (Exception e) {e.printStackTrace();}try {//如果Optional实例值为null，会执行orElseThrow()内对象的方法。并且这个orElseThrow内对象的方法必须是可以抛的，即异常对象。nullOptional.orElseThrow(Exception::new);} catch (Throwable e) {// 输出: nullSystem.out.println("【orElseThrow()】" + e.getMessage());e.printStackTrace();}
}

探测：

看到orElseThrow方法中的对象的get方法的返回值必须是一个可被抛出的对象，所以orElseThrow方法中对象的方法都是创建一个异常类。(Supplier他就一个方法，如果是lambda表达式，那么lambda表达式中的方法体就是这个get方法的方法体，这是lambda表达式的知识点。)

过滤

filter(Predicate p)

filter(Predicate p)：如果optional容器中的对象不为空，则执行断言函数p，如果p的结果为true，则返回原本的optional，否则返回空的optional。如果optional容器中的对象为空，那么也返回空的Optional。

@Test
public void test(){Optional<String> notNullOptional = Optional.ofNullable("xiaoxian");//如果是空，就返回空OptionalOptional<String> nullOptional = Optional.ofNullable(null);Optional<String> aaa = nullOptional.filter(item -> item.equals("kkk"));System.out.println(aaa);// 如果不是空，且满足filter条件，则返回该Option容器中的对象实例，否则返回空Optional。value就是指Optional容器中的对象。Optional<String> filterTrue = notNullOptional.filter((value) -> value.length() > 6);//输出：xiaoxianSystem.out.println("【filter】" + filterTrue.orElse("不滿足filter條件"));//如果不是空，且不满足filter条件，则返回空Optional。value就是指Optional容器中的对象。Optional<String> filterFalse = notNullOptional.filter((value) -> value.length() > 10);//输出：【filter】Optional.emptySystem.out.println("【filter】" + filterFalse);
}

映射

map(Function<T, U> mapper)

map(Function<T, U> mapper)：如果optional容器中对象不为空，则将optional中的对象 t 映射成另外一个对象 u，并将 u 存放到一个新的optional容器中。否则返回空Optional。

@Test
public void test(){Optional<String> notNullOptional = Optional.ofNullable("xiaoxian");//如果是空，就返回空OptionalOptional<String> nullOptional = Optional.ofNullable(null);// 如果Optional实例值非null，执行map(lambda表达式，任意类型)，返回新的Optional实例Optional<String> notNullToUpperCase = notNullOptional.map((value) -> value.toUpperCase());// 输出：map后是一个新的Optional对象System.out.println(notNullOptional==notNullToUpperCase?"是一个对象":"map后是一个新的Optional对象");// 输出：XIAOXIANSystem.out.println("【map()】" + notNullToUpperCase.orElse("No value found"));Optional<Integer> notNullToInteger = notNullOptional.map((value) -> 1);// 输出：1System.out.println("【map()】" + notNullToInteger.orElse(2));// 如果Optional实例值为null，不用执行map()，返回空OptionalOptional<String> emptyToUpperCase = nullOptional.map((value) -> value.toUpperCase());// 输出：No value foundSystem.out.println("【map()】" + emptyToUpperCase.orElse("No value found"));
}

flatMap(Function< T,Optional< U >> mapper)

flatMap()：flatMap()与 map()类似，区别在于：他们传入方法的lambda表达式的返回类型

map()：lambda表达式返回值可以是任意类型，在map函数返回之前会包装为Optional
flatMap：lambda表达式返回值必须是Optionl实例，不会自动把结果包装为Optional，需要你手动把返回值封装为Optional才行。

@Test
public void test(){Optional<String> notNullOptional = Optional.ofNullable("xiaoxian");//如果是空，就返回空OptionalOptional<String> nullOptional = Optional.ofNullable(null);// 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()));// 输出：XIAOXIANSystem.out.println("【flatMap()】" + notNullToUpperCase.orElse("No value found"));//如果Optional容器中实例的值为null，不用执行flatMap(lambda表达式)，返回空OptionalOptional<String> optional = nullOptional.flatMap((value) -> Optional.of(value.toUpperCase()));// 输出：No value foundSystem.out.println("【flatMap()】" + optional.orElse("No value found"));
}

使用推荐

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);}

推荐示例代码

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;}
}