T orElseThrow(Supplier exceptionSupplier) throws X {
- return Assert.notNull(this.value, exceptionSupplier);
- }
-
- /**
- * 检查值是否为空
- *
- * @return 是否为空
+ * @return 包裹里元素的值存在为 {@code true}，否则为{@code false}
*/
public boolean isPresent() {
- return null != this.value;
+ return value != null;
}
/**
- * 如果值非空，则使用指定函数处理值
+ * 判断包裹里元素的值是否不存在，不存在为 {@code true}，否则为{@code false}
*
- * @param consumer 处理非空对象的函数
+ * @return 包裹里元素的值不存在 则为 {@code true}，否则为{@code false}
+ * @since 11 这是jdk11{@link Optional}中的新函数
*/
- public void ifPresent(Consumer consumer) {
+ public boolean isEmpty() {
+ return value == null;
+ }
+
+ /**
+ * 如果包裹里的值存在，就执行传入的操作({@link Consumer#accept})
+ *
+ * @param action 你想要执行的操作
+ * @throws NullPointerException 如果包裹里的值存在，但你传入的操作为{@code null}时抛出
+ * @apiNote 例如如果值存在就打印结果
+ * {@code
+ * Opt.ofNullable("Hello Hutool!").ifPresent(System.out::println);
+ * }
+ */
+ public void ifPresent(Consumer action) {
if (value != null) {
- consumer.accept(value);
+ action.accept(value);
}
}
+ /**
+ * 如果包裹里的值存在，就执行传入的值存在时的操作({@link Consumer#accept})
+ * 否则执行传入的值不存在时的操作({@link Runnable}中的{@link Runnable#run})
+ *
+ * @param action 包裹里的值存在时的操作
+ * @param emptyAction 包裹里的值不存在时的操作
+ * @throws NullPointerException 如果包裹里的值存在时，执行的操作为 {@code null}, 或者包裹里的值不存在时的操作为 {@code null}，则抛出{@code NPE}
+ * @apiNote 例如值存在就打印对应的值，不存在则用{@code System.err.println}打印另一句字符串
+ * {@code
+ * Opt.ofNullable("Hello Hutool!").ifPresentOrElse(System.out::println, () -> System.err.println("Ops!Something is wrong!"));
+ * }
+ * @since 9 这是jdk9{@link Optional}中的新函数
+ */
+ public void ifPresentOrElse(Consumer action, Runnable emptyAction) {
+ if (value != null) {
+ action.accept(value);
+ } else {
+ emptyAction.run();
+ }
+ }
+
+ /**
+ * 判断包裹里的值存在并且与给定的条件是否满足 ({@link Predicate#test}执行结果是否为true)
+ * 如果满足条件则返回本身
+ * 不满足条件或者元素本身为空时返回一个返回一个空的{@code Opt}
+ *
+ * @param predicate 给定的条件
+ * @return 如果满足条件则返回本身, 不满足条件或者元素本身为空时返回一个返回一个空的{@code Opt}
+ * @throws NullPointerException 如果给定的条件为 {@code null}，抛出{@code NPE}
+ */
+ public OptionalBean filter(Predicate predicate) {
+ Objects.requireNonNull(predicate);
+ if (isEmpty()) {
+ return this;
+ } else {
+ return predicate.test(value) ? this : empty();
+ }
+ }
+
+ /**
+ * 如果包裹里的值存在，就执行传入的操作({@link Function#apply})并返回一个包裹了该操作返回值的{@code Opt}
+ * 如果不存在，返回一个空的{@code Opt}
+ *
+ * @param mapper 值存在时执行的操作
+ * @param 操作返回值的类型
+ * @return 如果包裹里的值存在，就执行传入的操作({@link Function#apply})并返回一个包裹了该操作返回值的{@code Opt}，
+ * 如果不存在，返回一个空的{@code Opt}
+ * @throws NullPointerException 如果给定的操作为 {@code null}，抛出 {@code NPE}
+ */
+ public OptionalBean map(Function mapper) {
+ Objects.requireNonNull(mapper);
+ if (isEmpty()) {
+ return empty();
+ } else {
+ return OptionalBean.ofNullable(mapper.apply(value));
+ }
+ }
+
+ /**
+ * 如果包裹里的值存在，就执行传入的操作({@link Function#apply})并返回该操作返回值
+ * 如果不存在，返回一个空的{@code Opt}
+ * 和 {@link OptionalBean#map}的区别为 传入的操作返回值必须为 {@link OptionalBean}
+ *
+ * @param mapper 值存在时执行的操作
+ * @param 操作返回值的类型
+ * @return 如果包裹里的值存在，就执行传入的操作({@link Function#apply})并返回该操作返回值
+ * 如果不存在，返回一个空的{@code Opt}
+ * @throws NullPointerException 如果给定的操作为 {@code null}或者给定的操作执行结果为 {@code null}，抛出 {@code NPE}
+ */
+ public OptionalBean flatMap(Function> mapper) {
+ Objects.requireNonNull(mapper);
+ if (isEmpty()) {
+ return empty();
+ } else {
+ @SuppressWarnings("unchecked")
+ OptionalBean r = (OptionalBean) mapper.apply(value);
+ return Objects.requireNonNull(r);
+ }
+ }
+
+ /**
+ * 如果包裹里元素的值存在，就执行对应的操作，并返回本身
+ * 如果不存在，返回一个空的{@code Opt}
+ *
+ * @param action 值存在时执行的操作
+ * @throws NullPointerException 如果值存在，并且传入的操作为 {@code null}
+ * @apiNote 属于 {@link #ifPresent}的链式拓展
+ * @author VampireAchao
+ */
+ public OptionalBean peek(Consumer action) {
+ Objects.requireNonNull(action);
+ if (isEmpty()) {
+ return OptionalBean.empty();
+ }
+ action.accept(value);
+ return this;
+ }
+
+ /**
+ * 如果包裹里元素的值存在，就返回本身，如果不存在，则使用传入的操作执行后获得的 {@code Opt}
+ *
+ * @return 如果包裹里元素的值存在，就返回本身，如果不存在，则使用传入的函数执行后获得的 {@code Opt}
+ * @throws NullPointerException 如果传入的操作为空，或者传入的操作执行后返回值为空，则抛出 {@code NPE}
+ * @since 9 这是jdk9{@link Optional}中的新函数
+ */
+ public OptionalBean or(Supplier> supplier) {
+ Objects.requireNonNull(supplier);
+ if (isPresent()) {
+ return this;
+ } else {
+ @SuppressWarnings("unchecked")
+ OptionalBean r = (OptionalBean) supplier.get();
+ return Objects.requireNonNull(r);
+ }
+ }
+
+ /**
+ * 如果包裹里元素的值存在，就返回一个包含该元素的 {@link Stream},
+ * 否则返回一个空元素的 {@link Stream}
+ *
+ * @return 返回一个包含该元素的 {@link Stream}或空的 {@link Stream}
+ * @apiNote 该方法能将 {@link OptionalBean} 中的元素传递给 {@link Stream}
+ * {@code
+ * Stream> os = ..
+ * Stream s = os.flatMap(Opt::stream)
+ * }
+ * @since 9 这是jdk9{@link Optional}中的新函数
+ */
+ public Stream stream() {
+ if (isEmpty()) {
+ return Stream.empty();
+ } else {
+ return Stream.of(value);
+ }
+ }
+
+ /**
+ * 如果包裹里元素的值存在，则返回该值，否则返回传入的{@code other}
+ *
+ * @param other 元素为空时返回的值，有可能为 {@code null}.
+ * @return 如果包裹里元素的值存在，则返回该值，否则返回传入的{@code other}
+ */
+ public T orElse(T other) {
+ return value != null ? value : other;
+ }
+
+ /**
+ * 如果包裹里元素的值存在，则返回该值，否则返回传入的操作执行后的返回值
+ *
+ * @param supplier 值不存在时需要执行的操作，返回一个类型与 包裹里元素类型 相同的元素
+ * @return 如果包裹里元素的值存在，则返回该值，否则返回传入的操作执行后的返回值
+ * @throws NullPointerException 如果之不存在，并且传入的操作为空，则抛出 {@code NPE}
+ */
+ public T orElseGet(Supplier supplier) {
+ return value != null ? value : supplier.get();
+ }
+
+ /**
+ * 如果包裹里的值存在，则返回该值，否则抛出 {@code NoSuchElementException}
+ *
+ * @return 返回一个不为 {@code null} 的包裹里的值
+ * @throws NoSuchElementException 如果包裹里的值不存在则抛出该异常
+ * @since 10 这是jdk10{@link Optional}中的新函数
+ */
+ public T orElseThrow() {
+ if (value == null) {
+ throw new NoSuchElementException("No value present");
+ }
+ return value;
+ }
+
+ /**
+ * 如果包裹里的值存在，则返回该值，否则执行传入的操作，获取异常类型的返回值并抛出
+ *
+ * @param 异常类型
+ * @param exceptionSupplier 值不存在时执行的操作，返回值继承 {@link Throwable}
+ * @return 包裹里不能为空的值
+ * @throws X 如果值不存在
+ * @throws NullPointerException 如果值不存在并且 传入的操作为 {@code null}或者操作执行后的返回值为{@code null}
+ * @apiNote 往往是一个包含无参构造器的异常 例如传入{@code IllegalStateException::new}
+ */
+ public T orElseThrow(Supplier exceptionSupplier) throws X {
+ if (value != null) {
+ return value;
+ } else {
+ throw exceptionSupplier.get();
+ }
+ }
+
+ /**
+ * 如果包裹里的值存在，则返回该值，否则执行传入的操作，获取异常类型的返回值并抛出
+ *
+ * @param 异常类型
+ * @param exceptionFunction 值不存在时执行的操作，返回值继承 {@link Throwable}
+ * @param message 作为传入操作执行时的参数，一般作为异常自定义提示语
+ * @return 包裹里不能为空的值
+ * @throws X 如果值不存在
+ * @throws NullPointerException 如果值不存在并且 传入的操作为 {@code null}或者操作执行后的返回值为{@code null}
+ * @apiNote 往往是一个包含 自定义消息 构造器的异常 例如
+ * {@code
+ * Opt.ofNullable(null).orElseThrow(IllegalStateException::new, "Ops!Something is wrong!");
+ * }
+ * @author VampireAchao
+ */
+ public T orElseThrow(Function exceptionFunction, String message) throws X {
+ if (value != null) {
+ return value;
+ } else {
+ throw exceptionFunction.apply(message);
+ }
+ }
+
+ /**
+ * 判断传入参数是否与 {@code Opt}相等
+ * 在以下情况下返回true
+ *
+ * - 它也是一个 {@code Opt} 并且
+ *
- 它们包裹住的元素都为空 或者
+ *
- 它们包裹住的元素之间相互 {@code equals()}
+ *
+ *
+ * @param obj 一个要用来判断是否相等的参数
+ * @return 如果传入的参数也是一个 {@code Opt}并且它们包裹住的元素都为空
+ * 或者它们包裹住的元素之间相互 {@code equals()} 就返回{@code true}
+ * 否则返回 {@code false}
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+
+ if (!(obj instanceof OptionalBean)) {
+ return false;
+ }
+
+ OptionalBean other = (OptionalBean) obj;
+ return Objects.equals(value, other.value);
+ }
+
+ /**
+ * 如果包裹内元素为空，则返回0，否则返回元素的 {@code hashcode}
+ *
+ * @return 如果包裹内元素为空，则返回0，否则返回元素的 {@code hashcode}
+ */
@Override
public int hashCode() {
return Objects.hashCode(value);
}
+
+ /**
+ * 返回包裹内元素调用{@code toString()}的结果，不存在则返回{@code null}
+ * return 包裹内元素调用{@code toString()}的结果，不存在则返回{@code null}
+ */
+ @Override
+ public String toString() {
+ return value != null
+ ? value.toString()
+ : null;
+ }
}
diff --git a/hutool-core/src/test/java/cn/hutool/core/bean/OptionalBeanTest.java b/hutool-core/src/test/java/cn/hutool/core/bean/OptionalBeanTest.java
new file mode 100644
index 000000000..367aba5e2
--- /dev/null
+++ b/hutool-core/src/test/java/cn/hutool/core/bean/OptionalBeanTest.java
@@ -0,0 +1,93 @@
+package cn.hutool.core.bean;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * {@link OptionalBean}的单元测试
+ *
+ * @author VampireAchao
+ */
+public class OptionalBeanTest {
+
+ @Test
+ public void ofBlankAbleTest() {
+ // ofBlankAble相对于ofNullable考虑了字符串为空串的情况
+ String hutool = OptionalBean.ofBlankAble("").orElse("hutool");
+ Assert.assertEquals("hutool", hutool);
+ }
+
+ @Test
+ public void getTest() {
+ // 和原版Optional有区别的是，get不会抛出NoSuchElementException
+ // 如果想使用原版Optional中的get这样，获取一个一定不为空的值，则应该使用orElseThrow
+ Object opt = OptionalBean.ofNullable(null).get();
+ Assert.assertNull(opt);
+ }
+
+ @Test
+ public void isEmptyTest() {
+ // 这是jdk11 Optional中的新函数，直接照搬了过来
+ // 判断包裹内元素是否为空，注意并没有判断空字符串的情况
+ boolean isEmpty = OptionalBean.empty().isEmpty();
+ Assert.assertTrue(isEmpty);
+ }
+
+ @Test
+ public void ifPresentOrElseTest() {
+ // 这是jdk9中的新函数，直接照搬了过来
+ // 存在就打印对应的值，不存在则用{@code System.err.println}打印另一句字符串
+ OptionalBean.ofNullable("Hello Hutool!").ifPresentOrElse(System.out::println, () -> System.err.println("Ops!Something is wrong!"));
+ OptionalBean.empty().ifPresentOrElse(System.out::println, () -> System.err.println("Ops!Something is wrong!"));
+ }
+
+ @Test
+ public void peekTest() {
+ User user = new User();
+ // 相当于ifPresent的链式调用
+ OptionalBean.ofNullable("hutool").peek(user::setUsername).peek(user::setNickname);
+ Assert.assertEquals("hutool", user.getNickname());
+ Assert.assertEquals("hutool", user.getUsername());
+
+ // 注意，传入的lambda中，对包裹内的元素执行赋值操作并不会影响到原来的元素
+ String name = OptionalBean.ofNullable("hutool").peek(username -> username = "123").peek(username -> username = "456").get();
+ Assert.assertEquals("hutool", name);
+ }
+
+ @Test
+ public void orTest() {
+ // 这是jdk9 Optional中的新函数，直接照搬了过来
+ // 给一个替代的Opt
+ String str = OptionalBean.ofNullable(null).or(() -> OptionalBean.ofNullable("Hello hutool!")).map(String::toUpperCase).orElseThrow();
+ Assert.assertEquals("HELLO HUTOOL!", str);
+
+ User user = User.builder().username("hutool").build();
+ OptionalBean userOptionalBean = OptionalBean.of(user);
+ // 获取昵称，获取不到则获取用户名
+ String name = userOptionalBean.map(User::getNickname).or(() -> userOptionalBean.map(User::getUsername)).get();
+ Assert.assertEquals("hutool", name);
+ }
+
+ @Test
+ public void orElseThrowTest() {
+ // 获取一个不可能为空的值，否则抛出NoSuchElementException异常
+ Object obj = OptionalBean.ofNullable(null).orElseThrow();
+ // 获取一个不可能为空的值，否则抛出自定义异常
+ Object assignException = OptionalBean.ofNullable(null).orElseThrow(IllegalStateException::new);
+ // 获取一个不可能为空的值，否则抛出带自定义消息的自定义异常
+ Object exceptionWithMessage = OptionalBean.empty().orElseThrow(IllegalStateException::new, "Ops!Something is wrong!");
+ }
+
+ @Data
+ @Builder
+ @NoArgsConstructor
+ private static class User {
+ private String username;
+ private String nickname;
+ }
+
+
+}