Optional学习笔记

本文是我在学习Optional类时候做的笔记，基于JDK8，如果有其他方法是基于后续版本的会用红色字体标注。 

of(value)和ofNullable(null)方法都是获取Optional对象的方法。

// 获取Optional对象的方法
// of方法参数不能是null    
Optional<String> op1 = Optional.of("test");
System.out.println(op1);
// ofNullable方法参数无限制可以是null，也可以不是
Optional<Integer> op2 = Optional.ofNullable(null);
System.out.println(op2);
Optional<Integer> op3 = Optional.ofNullable(123);
System.out.println(op3);

打印出来的结果如下，[ ]中的内容是传入的参数，传入null则为empty。

Optional[test]
Optional.empty
Optional[123]

 empty()：返回一个空的Optional对象。

// empty方法获取一个空的Optional对象。
Optional<String> op1 = Optional.of("test");
Optional<Integer> op2 = Optional.ofNullable(null);
// 创建Optional对象的时候不管有没有参数，最后都会指向同一个对象。
System.out.println(op1.empty() == op2.empty());// true

// empty方法的源码,返回的EMPTY是静态常量
private static final Optional<?> EMPTY = new Optional<>();
public static<T> Optional<T> empty() {
    @SuppressWarnings("unchecked")
    Optional<T> t = (Optional<T>) EMPTY;
    return t;
}

 isPresent()：判断Optional对象是否有值。

Optional<String> op1 = Optional.of("test");
Optional<Integer> op2 = Optional.ofNullable(null);
// isPresent方法判断当前Optional对象是否有实际内容
System.out.println(op1.isPresent());// true
System.out.println(op2.isPresent());// false
// get方法获取Optional对象中的内容
System.out.println(op1.get());// test
// 如果当前Optional为空对象调用get方法会报错，所以调用get方法之前先调用isPresent方法进行判断
System.out.println(op2.get());// java.util.NoSuchElementException: No value present

isEmpty()：判断Optional对象是否为空，与isPresent()正好相反。此方法JDK11之后的版本可用。

Optional<String> op1 = Optional.of("test");
boolean empty1 = op1.isEmpty();
Optional<Integer> op2 = Optional.ofNullable(null);
boolean empty2 = op2.isEmpty();
System.out.println(empty1);// false
System.out.println(empty2);// true

 ifPresent(Consumer):Optional对象如果有值则执行consumer中的accept方法，为空则什么都不做。

Optional<String> op1 = Optional.of("test");
Optional<Integer> op2 = Optional.ofNullable(null);
// Optional对象有值调用Consumer对象中的accept方法，空对象则不调用
op1.ifPresent(new Consumer<String>() {
	@Override
	public void accept(String str) {
		System.out.println(str);
	}
});
op2.ifPresent(new Consumer<Integer>() {
	@Override
	public void accept(Integer i) {
		System.out.println(i);
	}
});

 ifPresentOrElse(Consumer,Runnable)：参数实现两个接口Consumer和Runnable，Consumer接口是和ifPreset一样，区别在于对于空值的处理。ifPreset什么都不做，ifPresentOrElse会执行Runnable的实现方法。此方法JDK9之后的版本可用。

Optional<String> op1 = Optional.of("test");
Optional<Integer> op2 = Optional.ofNullable(null);
op1.ifPresentOrElse(new Consumer<String>() {
	@Override
	public void accept(String str) {
		System.out.println(str);
	}
}, new Runnable() {
	@Override
	public void run() {
		System.out.println("Optional is empty!");
	}
});
op2.ifPresentOrElse(new Consumer<Integer>() {
	@Override
	public void accept(Integer i) {
		System.out.println(i);
	}
}, new Runnable() {
	@Override
	public void run() {
		System.out.println("Optional is empty!");
	}
});
// 打印结果
// test
// Optional is empty!

源码如下：

public void ifPresent(Consumer<? super T> action) {
    if (value != null) {
        action.accept(value);
    }
}
public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
    if (value != null) {
        action.accept(value);
    } else {
        emptyAction.run();
    }
}

 orElse(value)：Optional对象如果有值则返回该值，为空则返回传入的参数。

Optional<String> op1 = Optional.of("test");
Optional<Integer> op2 = Optional.ofNullable(null);
// Optional对象如果有值，orElse会返回Optional对象对象中存储的值，为空则返回参数中的值
System.out.println(op1.orElse(null));// test
System.out.println(op2.orElse(null));// null

 orElseGet()：与orElse(value)方法一致，只是返回值的方式不同。

Optional<String> op1 = Optional.of("test");
Optional<Integer> op2 = Optional.ofNullable(null);
// Optional对象如果有值，orElseGet会返回Optional对象对象中存储的值，为空则返回自己指定的值
System.out.println(op1.orElseGet(() -> {
	return "1";
}));
System.out.println(op2.orElseGet(() -> {
	return 1;
}));

orElseThrow(Supplier)：Optional对象为空则抛异常，有值则什么都不做。

Optional<String> op1 = Optional.of("test");
Optional<Integer> op2 = Optional.ofNullable(null);
// Optional对象如果有值，orElseThrow方法什么都不做，为空则抛异常
try {
	op1.orElseThrow(() -> {
		throw new IllegalStateException();
	});
} catch (IllegalStateException e) {
	System.out.println("op1发生异常：" + e.getMessage());
	e.printStackTrace();
}
try {
	op2.orElseThrow(() -> {
		throw new IllegalStateException();
	});
} catch (IllegalStateException e) {
	System.out.println("op2发生异常：" + e.getMessage());
	e.printStackTrace();
}

 orElseThrow()：与orElseThrow(Supplier)相似，区别在于不用自己实现抛异常。此方法JDK10之后版本可用。

Optional<String> op1 = Optional.of("test");
Optional<String> op2 = Optional.ofNullable(null);
System.out.println(op1.orElseThrow());// test
System.out.println(op2.orElseThrow());// java.util.NoSuchElementException: No value present

 filter(Predicate)：判断Optional对象中的值是否符合条件，符合返回原值，否则返回空Optional对象。

Optional<String> op1 = Optional.of("test");
Optional<Integer> op2 = Optional.ofNullable(null);
// filter方法判断Optional对象中的值是否符合条件并返回新的Optional对象
Optional<String> newOp1 = op1.filter((o) -> o.equals("test"));
// Optional对象为空的话，则返回当前对象
Optional<Integer> newOp2 = op2.filter((o) -> o == 1);
System.out.println(newOp1);// Optional[test]
System.out.println(newOp2);// Optional.empty

源码如下：

public Optional<T> filter(Predicate<? super T> predicate) {
    Objects.requireNonNull(predicate);
    if (!isPresent())
    return this;
    else
    return predicate.test(value) ? this : empty();
}

map(Function)：对Optional对象进行函数运算，返回新的Optional对象。

// map方法对Optional对象进行函数运算，返回新的Optional对象
Optional<String> str1 = op1.map((o) -> "key" + o);
// Optional对象如果为空，则一个新的空Optional对象
Optional<String> str2 = op2.map((o) -> "key" + o);
System.out.println(str1.get());// keytest
System.out.println(str2.isPresent());// false

源码如下：

public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent())
        return empty();
    else {
        return Optional.ofNullable(mapper.apply(value));
    }
}

flatMap()：功能和map()类似。

Optional<String> op1 = Optional.of("test");
// flatMap方法与map方法类似，如果map方法采用和flatMap相同的写法，则返回值必须为Optional对象
Optional<Optional<String>> str1 = op1.map((o) -> {
	return Optional.of("key" + o);
});
Optional<String> str2 = op1.flatMap((o) -> {
	return Optional.of("key" + o);
});
System.out.println(str1.get().get());// keytest
System.out.println(str2.get());// keytest

源码如下：

public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent())
        return empty();
    else {
        return Objects.requireNonNull(mapper.apply(value));
    }
}

map()和flatMap()的区别在于传入非空对象时返回值的不同，map()返回值必须是Optional对象，flatMap()则可以是任意类型。

or(Supplier)：参数实现Supplier接口，Optional对象有值直接返回，为空则返回实现的get方法。此方法JDK9之后版本可用。

Optional<String> op1 = Optional.of("test");
Optional<String> op2 = Optional.of("");
Optional<String> op3 = Optional.ofNullable(null);
Optional<String> or1 = op1.or(new Supplier<Optional<? extends String>>() {
	@Override
	public Optional<? extends String> get() {
		return Optional.of("Optional is empty");
	}
});
Optional<String> or2 = op2.or(new Supplier<Optional<? extends String>>() {
	@Override
	public Optional<? extends String> get() {
		return Optional.of("Optional is empty");
	}
});
Optional<String> or3 = op3.or(new Supplier<Optional<? extends String>>() {
	@Override
	public Optional<? extends String> get() {
		return Optional.of("Optional is empty");
	}
});
System.out.println(or1);// Optional[test]
System.out.println(or2);// Optional[]
System.out.println(or3);// Optional[Optional is empty]

源码如下：

public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier) {
    Objects.requireNonNull(supplier);
    if (isPresent()) {
        return this;
    } else {
    @SuppressWarnings("unchecked")
    Optional<T> r = (Optional<T>) supplier.get();
        return Objects.requireNonNull(r);
    }
}

stream()：将一个Optional对象转换成Stream对象。有值返回当前值的Stream对象，为空则返回空的Stream对象。此方法JDK9之后版本可用。

Optional<String> op1 = Optional.of("test");
Optional<String> op2 = Optional.ofNullable(null);
Stream<String> stream1 = op1.stream();
Stream<String> stream2 = op2.stream();
System.out.println(stream1.findAny());// Optional[test]
System.out.println(stream2.findAny());// Optional.empty

源码如下：

public Stream<T> stream() {
    if (!isPresent()) {
        return Stream.empty();
    } else {
        return Stream.of(value);
    }
}