Java函数式编程之Optional

class OptionalOrderFactory{

    static Optional create(String id){
        //省略...
    }
}

String orderId = "xxx";
Optional op =  Optional.of(orderId).flatMap(id -> OptionalOrderFactory.create(id));

public Optional or(Supplier<? extends Optional> supplier) {
    // supplier存在性判断
    Objects.requireNonNull(supplier);
    // value不为NULL，则直接返回自身
    if (isPresent()) {
        return this;
    } else {
        // value为NULL，则返回supplier提供的Optional实例，做一次空判断
        @SuppressWarnings("unchecked")
        Optional r = (Optional) supplier.get();
        return Objects.requireNonNull(r);
    }
}

Order a = null;
Order b = select();
// 拿到的就是b订单实例包装的Optional
Optional op = Optional.ofNullable(a).or(b);

// 对value做NULL判断，转换为Stream类型
public Stream stream() {
    if (!isPresent()) {
        return Stream.empty();
    } else {
        return Stream.of(value);
    }
}

// 值不为NULL则直接返回value，否则返回other
public T orElse(T other) {
    return value != null ? value : other;
}

String v1 = null;
String v2 = "default";
// 拿到的就是v2对应的"default"值
String value = Optional.ofNullable(v1).orElse(v2);

// 值不为NULL则直接返回value，否则返回Supplier#get()
public T orElseGet(Supplier supplier) {
    return value != null ? value : supplier.get();
}

String v1 = null;
Supplier v2 = () -> "default";
// 拿到的就是v2对应的"default"值
String value = Optional.ofNullable(v1).orElseGet(v2);

// 如果值为NULL，则抛出NoSuchElementException，否则直接返回value
public T orElseThrow() {
    if (value == null) {
        throw new NoSuchElementException("No value present");
    }
    return value;
}

// 如果值不为NULL，则直接返回value，否则返回Supplier#get()提供的异常实例
public  T orElseThrow(Supplier exceptionSupplier) throws X {
    if (value != null) {
        return value;
    } else {
        throw exceptionSupplier.get();
    }
}

Optional.ofNullable(orderInfoVo.getAmount()).orElseThrow(()-> new IllegalArgumentException(String.format("%s订单的amount不能为NULL",orderInfoVo.getOrderId())));

public boolean equals(Object obj) {
    if (this == obj) {
        return true;
    }

    if (!(obj instanceof Optional)) {
        return false;
    }

    Optional other = (Optional) obj;
    return Objects.equals(value, other.value);
}

public int hashCode() {
    return Objects.hashCode(value);
}

Map map = new HashMap();
Optional op1 = Optional.of("throwable");
map.put(op1, true);
Optional op2 = Optional.of("throwable");
map.put(op2, false);
// 输出false
System.out.println(map.get(op1));

if(null != order){
    order.setAmount(orderInfoVo.getAmount());
}

Optional.ofNullable(order).ifPresent(o -> o.setAmount(orderInfoVo.getAmount()));

// 如果判断空的对象是OrderInfoVo如下
Order o = select();
OrderInfoVo vo = ...
Optional.ofNullable(vo).ifPresent(v -> o.setAmount(v.getAmount()));

if (null == orderInfoVo.getAmount()){
    throw new IllegalArgumentException(String.format("%s订单的amount不能为NULL",orderInfoVo.getOrderId()));
}
if (StringUtils.isBlank(orderInfoVo.getAddress()){
    throw new IllegalArgumentException(String.format("%s订单的address不能为空",orderInfoVo.getOrderId()));
}

Optional.ofNullable(orderInfoVo.getAmount()).orElseThrow(()-> new IllegalArgumentException(String.format("%s订单的amount不能为NULL",orderInfoVo.getOrderId())));
Optional.ofNullable(orderInfoVo.getAddress()).orElseThrow(()-> new IllegalArgumentException(String.format("%s订单的address不能为空",orderInfoVo.getOrderId())));

@Data
static class Customer {

    private Long id;
}

@Data
static class Order {

    private Long id;
    private String orderId;
    private Long customerId;
}

@Data
static class OrderDto {

    private String orderId;
}

// 模拟客户查询
private static List selectCustomers(List ids) {
    return null;
}

// 模拟订单查询
private static List selectOrders(List customerIds) {
    return null;
}

// main方法
public static void main(String[] args) throws Exception {
    List ids = new ArrayList();
    List view = Optional.ofNullable(selectCustomers(ids))
            .filter(cs -> !cs.isEmpty())
            .map(cs -> selectOrders(cs.stream().map(Customer::getId).collect(Collectors.toList())))
            .map(orders -> {
                List dtoList = new ArrayList();
                orders.forEach(o -> {
                    OrderDto dto = new OrderDto();
                    dto.setOrderId(o.getOrderId());
                    dtoList.add(dto);
                });
                return dtoList;
            }).orElse(Collections.emptyList());
}

// 假设VO有多个层级，每个层级都不知道父节点是否为NULL，如下
// - OrderInfoVo
//   - UserInfoVo
//     - AddressInfoVo
//        - address(属性)
// 假设我要为address属性赋值，那么就会产生箭头型代码。


// 常规方法
String address = "xxx";
OrderInfoVo o = ...;
if(null != o){
    UserInfoVo uiv = o.getUserInfoVo();
    if (null != uiv){
        AddressInfoVo aiv = uiv.getAddressInfoVo();
        if (null != aiv){
            aiv.setAddress(address);
        }
    }
}

// 使用Optional
String address = "xxx";
OrderInfoVo o = ...;
Optional.ofNullable(o).ifPresent(oiv-> {
      Optional.ofNullable(oiv.getUserInfoVo()).ifPresent(uiv -> {
           Optional.ofNullable(uiv.getAddressInfoVo()).ifPresent(aiv->{
                aiv.setAddress(address);
           })
      })
});