Optional

程序中对"空"，如空数组、空集合的体现形式可能是null或emplityList。如果是null，在使用时就需要我们进行null判断，防止抛空指针异常。常用的就是if else判断，但是如果存在多个if else 且它们之间存在着嵌套关系，代码写起来就复杂。这时候就可以使用Optonal的链式编程来解决。

api介绍

Modifier and Type	Method and Description
static <T> Optional<T>	empty() 返回一个空的Optional实例。此Optional不存在值。
Optional<T>	filter(Predicate<? super T> predicate) 如果存在一个值，且该值与给定predicate匹配，则返回一个描述该值的Optional，否则返回一个空Optional。
<U> Optional<U>	flatMap(Function<? super T,Optional<U>> mapper) 如果存在值，则对其应用提供的mapper映射函数，返回该结果，否则返回空的'Optional'。
T	get() 如果此选项中存在一个值，则返回该值，否则抛出NoTouchElementException。
void	ifPresent(Consumer<? super T> consumer) 如果存在值，则对其应用提供的consumer函数，否则不执行任何操作。
boolean	isPresent() 如果存在值，则返回true，否则返回false。
<U> Optional<U>	map(Function<? super T,? extends U> mapper) 如果存在一个值，则对其应用提供的映射函数，如果结果为非空，则返回一个描述结果的可选值。否则返回一个空的可选值。
static <T> Optional<T>	of(T value) 返回具有指定的当前非空值的可选值。
static <T> Optional<T>	ofNullable(T value) 返回一个描述指定值的可选值，如果非空，则返回一个空可选值。
T	orElse(T other) 返回值（如果存在），否则返回其他值。
T	orElseGet(Supplier<? extends T> other) 如果存在，则返回该值，否则调用other并返回该调用的结果。
<X extends Throwable>T	orElseThrow(Supplier<? extends X> exceptionSupplier) 返回包含的值（如果存在），否则抛出由提供的供应商创建的异常
String	toString()Returns a non-empty string representation of this Optional suitable for debugging.

 

 案例1

// 场景1：使用Optional对getName方法进行优化
	private static String getName_optional_opt(User user) {
		// 1.Optional.ofNullable创建一个可能包含null的Optional
		// 2.map(User::getName)，如果Optional包含的值不为null，则调用User::getName,返回name
		// 3.orElseGet(() -> "Unknown") 如果Optional包含的值为null， 则返回Unknown
		return Optional.ofNullable(user).map(User::getName).orElseGet(() -> "Unknown");
	}

	private static String getName(User user) {
		if (user == null) {
			return "Unknown";
		} else {
			return user.getName();
		}
	}

	class User {
		String name;

		public String getName() {
			return name;
		}

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

案例2

// 场景2：使用Optional对getSum进行优化
	private static Optional<Integer> getSum_optional_opt(){
		return Optional.ofNullable(getA())
				.flatMap(a -> Optional.ofNullable(getB()).map(b -> a + b))
				.flatMap(ab -> Optional.ofNullable(getC()).map(c -> ab * c));
	}

	private static Integer getSum() {
		Integer a = getA();
		if (a != null) {
			Integer b = getB();
			if (b != null) {
				Integer c = getC();
				if (c != null) {
					return (a + b) * c;
				} else return null;
			} else return null;
		} else return null;
	}

	private static Integer getA() {
		if (Math.random() > 1) {
			return null;
		}
		return Integer.valueOf(1);
	}

	private static Integer getB() {
		if (Math.random() > 1) {
			return null;
		}
		return Integer.valueOf(1);
	}

	private static Integer getC() {
		if (Math.random() > 1) {
			return null;
		}
		return Integer.valueOf(3);
	}

orElse和orElseGet区别

	private static void orElseAndOrElseGetDiffer() {
		// orElse和orElseGet的区别： testValue不为null的情况下，orElse仍然调用了getDefaultValue()方法，而orElseGet并没有
		String testValue = "a";
		Optional.ofNullable(testValue).orElse(getDefaultValue());
		System.out.println("----");
		Optional.ofNullable(testValue).orElseGet(OptionalTest::getDefaultValue);
	}

	private static String getDefaultValue() {
		System.out.println("getDefaultValue");
		return "getDefaultValue";
	}

map和flatMap区别

map中获取的返回值自动被Optional包装,即返回值 -> Optional<返回值>

flatMap中返回值保持不变,但必须是Optional类型,即Optional<返回值> -> Optional<返回值>

public class OptionalTest {
	public static void main(String[] args) {
		TicketInfo flightTicketInfo = null;

		Optional<Optional<String>> s1 = Optional.ofNullable(flightTicketInfo).map(OptionalTest::getOrderNumber);

		Optional<String> s2 = Optional.ofNullable(flightTicketInfo).map(TicketInfo::getOrderNumber);

		Optional<String> s3 = Optional.ofNullable(flightTicketInfo).flatMap(OptionalTest::getOrderNumber);
	}

	private static Optional<String> getOrderNumber(TicketInfo flightTicketInfo) {
		return Optional.ofNullable(flightTicketInfo).map(f -> f.getOrderNumber());
	}


	class TicketInfo {

		private String orderNumber;

		public String getOrderNumber() {
			return orderNumber;
		}

	}