日拱一卒：Lambda 之 Map 操作

1. Map

public interface Map<K,V> {
    default V computeIfAbsent(K key,
            Function<? super K, ? extends V> mappingFunction)

    default V computeIfPresent(K key,
            BiFunction<? super K, ? super V, ? extends V> remappingFunction)
}

2. computeIfAbsent()

@Test
public void computeIfAbsent() {
    Map<String, String> map = new HashMap<>();
    map.put("key1", "100");
    map.put("key2", "200");
    map.put("key3", "300");
    System.out.println("HashMap:\n " + map);

    // key3 存在，不执行 mappingFunction
    map.computeIfAbsent("key3", key -> "301");
    map.computeIfAbsent("key4", key -> "401");
    System.out.println("HashMap:\n " + map);
}

打印结果

HashMap:
 {key1=100, key2=200, key3=300}
HashMap:
 {key1=100, key2=200, key3=300, key4=401}

2.2 示例2

@Test
public void computeIfAbsent2() {
    Map<String, List<String>> map = new HashMap<>();
    map.put("key1", Lists.newArrayList("100", "101"));
    map.put("key2", Lists.newArrayList("200"));
    map.put("key3", Lists.newArrayList("300"));
    System.out.println("HashMap:\n " + map);

    map.computeIfAbsent("key3", key -> Lists.newArrayList("301"));
    System.out.println("HashMap:\n " + map);

    map.computeIfAbsent("key3", key -> Lists.newArrayList("301")).add("302");
    System.out.println("HashMap:\n " + map);
}

打印结果

HashMap:
 {key1=[100, 101], key2=[200], key3=[300]}
HashMap:
 {key1=[100, 101], key2=[200], key3=[300]}
HashMap:
 {key1=[100, 101], key2=[200], key3=[300, 302]}

2.3 示例3

@Test
public void computeIfAbsent3() {
    Map<String, List<String>> map = new HashMap<>();
    map.put("key1", Lists.newArrayList("100", "101"));
    map.put("key2", Lists.newArrayList("200"));
    map.put("key3", Lists.newArrayList("300"));
    System.out.println("HashMap:\n " + map);

    // key -> new ArrayList<>() 作用是指定默认值
    map.computeIfAbsent("key3", key -> new ArrayList<>()).add("301");
    map.computeIfAbsent("key4", key -> new ArrayList<>()).add("401");
    System.out.println("HashMap:\n " + map);
}

打印结果

HashMap:
 {key1=[100, 101], key2=[200], key3=[300]}
HashMap:
 {key1=[100, 101], key2=[200], key3=[300, 301], key4=[401]}

3. computeIfPresent()

/**
 * computeIfAbsent(K key, Function mappingFunction)
 *  若map中无对应的key，则执行lambda表达式生成一个默认值并放入map中并返回，否则返回map中已有的值
 *
 * computeIfPresent(K key, BiFunction remappingFunction)
 *  若map中存在对应的key，则对其value执行lambda表达式生成一个新值并放入map中并返回，否则返回null
 */
@Test
public void demo() {
    Map<String, String> map = new HashMap<>();
    map.put("key1", "100");
    map.put("key2", "200");
    map.put("key3", "300");
    System.out.println("HashMap:\n " + map);

    String absentValue = map.computeIfAbsent("key3", key -> "301");
    System.out.println("absentValue: " + absentValue + "\n HashMap:\n " + map);

    String presentValue = map.computeIfPresent("key3", (key, value) -> "301");
    System.out.println("presentValue:" + presentValue + "\n HashMap:\n " + map);

    String presentValue2 = map.computeIfPresent("key4", (key, value) -> "401");
    System.out.println("presentValue2:" + presentValue2 + "\n HashMap:\n " + map);
}

4. List 放入 Map

@Test
public void defaultMap() {
    List<OrderDTO> orders = Lists.newArrayList(new OrderDTO("A1001", "1001", 1),
            new OrderDTO("A1002", "1002", 1), new OrderDTO("A1002", "1003", 1));

    Map<String, List<OrderDTO>> orderByCodeMap = new HashMap<>();
    for (OrderDTO order : orders) {
        orderByCodeMap.computeIfAbsent(order.getOrderCode(), key -> new ArrayList<>()).add(order);
    }
    System.out.println(orderByCodeMap);
}

方式二：通过自定义一个有默认值的 DefaultHashMap 来实现

@Test
public void defaultMap() {
    List<OrderDTO> orders = Lists.newArrayList(new OrderDTO("A1001", "1001", 1),
            new OrderDTO("A1002", "1002", 1), new OrderDTO("A1002", "1003", 1));

    Map<String, List<OrderDTO>> orderMap = new DefaultHashMap<>(ArrayList::new);
    for (OrderDTO order : orders) {
        orderMap.get(order.getOrderCode()).add(order);
    }
    // 相同的 orderCode 会合并到一个List<OrderDTO>
    System.out.println(orderMap);
}

public class DefaultHashMap<K, V> extends HashMap<K, V> {
    Function<K, V> function;

    public DefaultHashMap(Supplier<V> supplier) {
        this.function = k -> supplier.get();
    }

    @Override
    @SuppressWarnings("unchecked")
    public V get(Object key) {
        return super.computeIfAbsent((K) key, this.function);
    }
}