日拱一卒：Lamdba 之 Optional 操作

1. Optional 类

• Optional<T>类（java.util.Optional）是一个容器类，代表一个值存在或不存在

public final class Optional<T> {
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }
}

1.1 Optional 转为 Stream 操作

@Test
public void optionalToStream() {
    List<OrderDTO> orders = Stream.of(new OrderDTO("A001", "1001", 0),
                    new OrderDTO("A002", "1002", 1),
                    new OrderDTO("A003", "1003", 1))
            .collect(Collectors.toList());

    String orderCode = Optional.ofNullable(orders)
            .orElseGet(Collections::emptyList) // .orElse(Collections.emptyList())
            .stream()
            .findFirst()
            .map(OrderDTO::getOrderCode)
            .orElse(null);
}
}

image.png

2. orElse() vs orElseGet()

public final class Optional<T> {
    public T orElse(T other) {
        return value != null ? value : other;
    }

    public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }
}

2.1 示例1

@Test
public void optionalElse() {
    OrderDTO orderDTO = new OrderDTO("A001", "1001");
    String orderCode = Optional.ofNullable(orderDTO)
            .orElseGet(OrderDTO::new)
            .getOrderCode();
}

测试 null 对象

@Test
public void optionalElseDemo() {
    System.out.println(optionalElseDemo(new OrderDTO("A001", "1001")));
    System.out.println(optionalElseDemo(null));
}

public String optionalElseDemo(OrderDTO orderDTO) {
    // return Optional.ofNullable(orderDTO)
    //         .orElse(new OrderDTO())
    //         .getOrderCode();

    return Optional.ofNullable(orderDTO)
            .orElseGet(OrderDTO::new)
            .getOrderCode();
}

2.2 示例2

@Test
public void optionalElseGet() {
    System.out.println(optionalElse(new OrderDTO("A001", "1001")));
    System.out.println(optionalElse(null));
    System.out.println("############");
    System.out.println(optionalElseGet(new OrderDTO("A001", "1001")));
    System.out.println(optionalElseGet(null));
}

/**
 * orElse(): 不管 orderDTO 是否为null，newInstance()都会执行
 */
public String optionalElse(OrderDTO orderDTO) {
    return Optional.ofNullable(orderDTO)
            .orElse(newInstance())
            .getOrderCode();
}

/**
 *  orElseGet(Supplier)是orElse方法的延迟调用版
 *      Supplier方法只有在Optional对象不含值时才执行调用
 */
public String optionalElseGet(OrderDTO orderDTO) {
    // orElseGet() 只在 orderDTO 为 null 时，newInstance() 才会执行
    return Optional.ofNullable(orderDTO)
            .orElseGet(this::newInstance)
            .getOrderCode();
}

打印结果

....
A001
....
null
############
A001
....
null

3. map()

@Test
public void optionalMap() {
    List<OrderDTO> orders = Stream.of(new OrderDTO("A001", "1001", 0),
                    new OrderDTO("A002", "1002", 1),
                    new OrderDTO("A003", "1003", 1))
            .collect(Collectors.toList());

    String orderCode = Optional.ofNullable(orders)
            .map(list -> list.stream().findFirst().orElse(new OrderDTO()))
            .map(OrderDTO::getOrderCode)
            .orElse(null);
}

Optional.map() 源码

public final class Optional<T> {
    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));
        }
    }
}

4. ifPresent(Consumer)

• isPresent()将在Optional包含值的时候返回true，否则返回false
• ifPresent(Consumer<T> block)会在值存在的时候执行给定的代码块

public final class Optional<T> {
    public boolean isPresent() {
        return value != null;
    }

    public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }
}

4.1 示例

@Test
public void present() {
    List<OrderDTO> orders = Stream.of(new OrderDTO("A001", "1001", 0),
                    new OrderDTO("A002", "1002", 1),
                    new OrderDTO("A003", "1003", 1))
            .collect(Collectors.toList());

    boolean isPresent = Optional.ofNullable(orders).isPresent();

    Optional.ofNullable(orders).ifPresent(list -> list.forEach(System.out::println));
}

4.2 示例

@Test
public void ifPresent() {
    OrderVO orderVO = new OrderVO("A001", "");
    Map<String, String> featureMap = new HashMap<>();
    featureMap.put("key", "value1");
    orderVO.setFeatureMap(featureMap);
    OrderDTO orderDTO = new OrderDTO();

    fillOrder(orderVO, orderDTO);
    System.out.println(orderDTO);
}

public void fillOrder(OrderVO orderVO, OrderDTO orderDTO) {
    Optional.ofNullable(orderVO)
            .map(OrderVO::getTradeId)
            .ifPresent(orderDTO::setTradeId);

    Optional.ofNullable(orderVO)
            .map(o -> o.getFeature("key"))
            .filter(StringUtils::isNotEmpty)
            .ifPresent(str -> orderDTO.addFeature("key", orderVO.getFeature("key")));
}