日拱一卒：lambda 之 map 操作

1. Stream

public interface Stream<T> extends BaseStream<T, Stream<T>> {
    <R> Stream<R> map(Function<? super T, ? extends R> mapper);
    LongStream mapToLong(ToLongFunction<? super T> mapper);
    Stream<T> distinct();
}

public interface LongStream extends BaseStream<Long, LongStream> {
    Stream<Long> boxed();
}

前置：定一个List, 转为 Map

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

    Map<String, OrderDTO> orderMap = Optional.ofNullable(orders)
            .orElse(Collections.emptyList())
            .stream()
            .collect(Collectors.toMap(OrderDTO::getTradeId, Function.identity()));
    System.out.println(JSON.toJSONString(orderMap));
}

1.1 map(Function)

List<String> tradeIdsByList = Optional.ofNullable(orders)
        .orElse(Collections.emptyList())
        .stream()
        .map(OrderDTO::getTradeId)
        .collect(Collectors.toList());

1.2 mapToLong(ToLongFunction)

List<Long> tradeIdsByMap = Optional.ofNullable(orderMap.keySet())
        .orElse(Collections.emptySet())
        .stream()
        .mapToLong(Long::parseLong)
        .boxed()
        .distinct()
        .collect(Collectors.toList());

2. toMap()

2.1 toMap(Function keyMapper, Function valueMapper)

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

    /*
     * toMap(Function keyMapper, Function valueMapper)
     *  缺点：duplicate key elements, java.lang.IllegalStateException: Duplicate key
     *
     * Function.identity() <==> element -> element
     */
    Map<String, OrderDTO> orderMap = Optional.ofNullable(orders)
            .orElse(Collections.emptyList())
            .stream()
            .collect(Collectors.toMap(OrderDTO::getOrderCode, Function.identity()));
    
}

2.2 toMap(Function keyMapper, Function valueMapper, BinaryOperator<U> mergeFunction)

@Test
public void toMap2() {
    List<OrderDTO> orders = Stream.of(new OrderDTO("A001", "1001", 1),
                    new OrderDTO("A002", "1002", 1))
            .collect(Collectors.toList());
    orders.add(new OrderDTO("A002", "1003", 1));
    /*
     * toMap(Function keyMapper, Function valueMapper, BinaryOperator<U> mergeFunction)
     *
     * mergeFunction: The mergeFunction is a function that is called only if there are duplicate key elements present in our final Map
     *
     * e.g.
     *  (existing, replacement) -> existing
     *  (existing, replacement) -> replacement
     */
    Map<String, OrderDTO> orderMap = Optional.ofNullable(orders)
            .orElse(Collections.emptyList())
            .stream()
            .collect(Collectors.toMap(OrderDTO::getOrderCode, t -> t, (o, n) -> o));
    System.out.println(orderMap);
}

当有重复key时，抛异常

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

    // c: throwable
    Map<String, OrderDTO> orderMap = Optional.ofNullable(orders)
            .orElse(Collections.emptyList())
            .stream()
            .collect(Collectors.toMap(OrderDTO::getOrderCode, t -> t,
                    (o, n) -> {throw new IllegalStateException("Duplicate key");}));
    System.out.println(orderMap);
}