Optional 类
Optional 类(java.util.Optional) 是一个容器类，代表一个值存在或不存在， 原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且 可以避免空指针异常。
常用方法：
- Optional.of(T t) : 创建一个 Optional 实例
- Optional.empty() : 创建一个空的 Optional 实例
- Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
- isPresent() : 判断是否包含值
- orElse(T t) : 如果调用对象包含值，返回该值，否则返回t
- orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值
- map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回Optional.empty()
- flatMap(Function mapper):与 map 类似，要求返回值必须是Optional
重复注解与类型注解
Java 8对注解处理提供了两点改进：可重复的注解及可用于类型的注解
image.png
代码演示
####### Goddess
package com.www.java8.optional;
/**
* <p>
*
* @author Www
* <p>
* 邮箱： 483223455@qq.com
* <p>
* 创建时间: 2022/8/15 17:28 星期一
* <p>
*/
public class Goddess {
private String name;
public Goddess() {
}
public Goddess(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Goddess{" +
"name='" + name + '\'' +
'}';
}
}
####### Man
package com.www.java8.optional;
/**
* <p>
*
* @author Www
* <p>
* 邮箱： 483223455@qq.com
* <p>
* 创建时间: 2022/8/15 17:28 星期一
* <p>
*/
public class Man {
private Goddess goddess;
public Man(Goddess goddess) {
this.goddess = goddess;
}
public Man() {
}
public Goddess getGoddess() {
return goddess;
}
public void setGoddess(Goddess goddess) {
this.goddess = goddess;
}
@Override
public String toString() {
return "Man{" +
"goddess=" + goddess +
'}';
}
}
NewMan
package com.www.java8.optional;
import java.util.Optional;
/**
* <p>
*
* @author Www
* <p>
* 邮箱： 483223455@qq.com
* <p>
* 创建时间: 2022/8/15 17:35 星期一
* <p>
*/
public class NewMan {
private Optional<Goddess> goddess= Optional.empty();
public NewMan(Optional<Goddess> goddess) {
this.goddess = goddess;
}
public NewMan() {
}
public Optional<Goddess> getGoddess() {
return goddess;
}
public void setGoddess(Optional<Goddess> goddess) {
this.goddess = goddess;
}
@Override
public String toString() {
return "NewMan{" +
"goddess=" + goddess +
'}';
}
}
####### OptionalTest
package com.www.java8.optional;
import com.www.java8.entity.Employee;
import org.junit.Test;
import java.util.Optional;
/**
* <p>
*
* @author Www
* <p>
* 邮箱： 483223455@qq.com
* <p>
* 创建时间: 2022/8/15 17:09 星期一
* <p>
*/
public class OptionalTest {
/**
* Optional<T> 类(java.util.Optional) 是一个容器类，代表一个值存在或不存在原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。
* <p>
* <p>
* <p>
* <p>
* <p>
* 常用方法：
* <p>
* <p>
* Optional.of(T t) : 创建一个 Optional 实例
* <p>
* Optional.empty() : 创建一个空的 Optional 实例
* <p>
* Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
* <p>
* isPresent() : 判断是否包含值
* <p>
* orElse(T t) : 如果调用对象包含值，返回该值，否则返回t
* <p>
* orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值
* <p>
* map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
* <p>
* flatMap(Function mapper):与 map 类似，要求返回值必须是Optional
*/
@Test
public void test() {
Optional<Employee> employee = Optional.of(new Employee());
// Optional<Employee> employee = Optional.of(null);
Employee employee1 = employee.get();
System.out.println(employee1);
}
/**
* 创建一个空的 Optional
*/
@Test
public void test1() {
Optional<Object> empty = Optional.empty();
System.out.println("empty.get() = " + empty.get());
}
/**
*
*/
@Test
public void test2() {
Optional<Employee> employee = Optional.ofNullable(null);
if (employee.isPresent()) {
System.out.println("employee.get() = " + employee.get());
}
Employee employee1 = employee.orElse(new Employee("12", 12, 21.3, Employee.Status.FREE));
System.out.println(employee1);
Employee employee2 = employee.orElseGet(() -> new Employee());
System.out.println(employee2);
}
/**
*
*/
@Test
public void test3() {
Optional<Employee> employee = Optional.ofNullable(new Employee("12", 12, 21.3, Employee.Status.FREE));
Optional<String> s = employee.map(Employee::getName);
System.out.println(s.get());
Optional<String> s1 = employee.flatMap(e -> Optional.ofNullable(e.getName()));
System.out.println("s1 = " + s1.get());
}
/**
*
*/
@Test
public void test4() {
// Man man = new Man();
//// // String goddessName = getGoddessName(man);
// System.out.println(goddessName);
Optional<Goddess> gn = Optional.ofNullable(null);
Optional<NewMan> newMan = Optional.ofNullable(new NewMan(gn));
String goddessNewMan = getGoddessNewMan(newMan);
System.out.println("goddessNewMan = " + goddessNewMan);
}
/**
* 获取 Goddess 的名字
*
* @param man
* @return
*/
private String getGoddessName(Man man) {
return man.getGoddess().getName();
}
private String getGoddessNewMan(Optional<NewMan> newMan) {
return newMan.orElse(new NewMan())
.getGoddess()
.orElse(new Goddess("w"))
.getName();
}
}
