Java8学习笔记 — Optional

Optional<T>类（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

Godness.java

public class Godness {
   
	private String name;

	public Godness() {}

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

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

}

Man.java

public class Man {

	private Godness godness;

	public Man() {}

	public Man(Godness godness) {
		this.godness = godness;
	}

	public Godness getGodness() {
		return godness;
	}
	public void setGodness(Godness godness) {
		this.godness = godness;
	}

	@Override
	public String toString() {
		StringBuilder builder = new StringBuilder();
		builder.append("Man [godness=");
		builder.append(godness);
		builder.append("]");
		return builder.toString();
	}

}

NewMan.java

import java.util.Optional;

public class NewMan {

	private Optional<Godness> godness = Optional.empty();

	public NewMan() {

	}

	public NewMan(Optional<Godness> godness) {
		this.godness = godness;
	}

	public Optional<Godness> getGodness() {
		return godness;
	}

	public void setGodness(Optional<Godness> godness) {
		this.godness = godness;
	}

	@Override
	public String toString() {
		StringBuilder builder = new StringBuilder();
		builder.append("NewMan [godness=");
		builder.append(godness);
		builder.append("]");
		return builder.toString();
	}

}

Optional类常用方法演示：

import java.util.Optional;
import org.junit.Test;
import com.its.java8.lambda.Employee;
import com.its.java8.lambda.Employee.Status;

public class TestOptional {
	/*
	 * 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
	 * 
	 */
	@Test
	public void test4() {
		Optional<Employee> op = Optional.ofNullable(new Employee("张三", 18, 8888.88, Status.FREE));
		Optional<String> str = op.map((e) -> e.getName());
		System.out.println(str.get());

		Optional<String> str2 = op.flatMap((e) -> Optional.of(e.getName()));
		System.out.println(str2.get());
	}
	
	@Test
	public void test3() {
		Optional<Employee> op = Optional.ofNullable(null);

		if (op.isPresent()) {
			System.out.println(op.get());
		}

		Employee emp = op.orElse(new Employee("张三", 18, 8888.88, Status.FREE));
		System.out.println(emp);

		Employee employee = op.orElseGet(() -> new Employee("李四", 28, 9999.99, Status.BUSY));
		System.out.println(employee);
	}

	@Test
	public void test2() {
		Optional<Employee> op = Optional.empty();
		System.out.println(op.get());
	}

	@Test
	public void test1() {
		Optional<Employee> op = Optional.of(new Employee());
		Employee emp = op.get();
		System.out.println(emp);
	}


	// 例题
	@Test
	public void test5() {
		// Man man = new Man();
		// String name = getGodnessName(man);
		// System.out.println(name);

		Optional<Godness> gn = Optional.ofNullable(new Godness("波多老师"));
		Optional<NewMan> man = Optional.ofNullable(new NewMan(gn));
		String name = getGodnessName2(man);
		System.out.println(name);
	}
	
	public String getGodnessName2(Optional<NewMan> man) {
		return man.orElse(new NewMan()).getGodness().orElse(new Godness("苍老师")).getName();
	}
	
	// 需求：获取一个男人心中女神的名字
	public String getGodnessName(Man man) {
		if (null != man) {
			Godness gn = man.getGodness();
			if (null != gn) {
				return gn.getName();
			}
		}
		return "苍老师";
	}
	
}