繁体   English   中英

如何使Map可选的值是否存在

[英]How to make Map Optional on whether its every optional value is present

我有一个包含许多可选值的Map:

Map<MyCoolKey, Optional<MyCoolValue>>

我想将此Map转换为Optional<Map<>>

Optional<Map<MyCoolKey, MyCoolValue>>
  • 如果每个Optional<MyCoolValue>都存在:应该存在Optional<Map<>>
  • 如果任何 Optional<MyCoolValue>不存在: Optional<Map<>>应该不存在。

我试过这个,我怀疑我的代码会起作用,但它有点啰嗦:

final Map<MyCoolKey, Optional<MyCoolValue>> myCoolMap;
final Optional<Map<MyCoolKey, MyCoolValue>> optionalMap = myCoolMap
                .entrySet()
                .stream()
                .map(e -> e
                        .getValue()
                        .flatMap(value -> Optional.<Map.Entry<MyCoolKey, MyCoolValue>>of(
                                new AbstractMap.SimpleEntry<>(
                                        e.getKey(),
                                        value
                                )
                        ))
                )
                .collect(
                        () -> Optional.<Map<MyCoolKey, MyCoolValue>>of(new HashMap<>()),
                        (optAcc, optEntry) -> optAcc.flatMap(
                                acc -> optEntry.map(
                                        entry -> {
                                            acc.put(entry.getKey(), entry.getValue());
                                            return acc;
                                        })
                        ),
                        (optAcc1, optAcc2) -> optAcc1.flatMap(
                                acc1 -> optAcc2.map(
                                        acc2 -> {
                                            acc1.putAll(acc2);
                                            return acc1;
                                        }
                                )
                        )
                );

有一个更好的方法吗? “更好”意味着正确,表现,美丽。 我更喜欢能够在一个流中完成整个操作的答案。

下面是纯流溶液的例子(不if S和三元运营商)

final Map<MyCoolKey, Optional<MyCoolValue>> myCoolMap = new HashMap<>();

Optional<Map<MyCoolKey, MyCoolValue>> output = Optional.of(myCoolMap)
    .filter(map -> map.values().stream().allMatch(Optional::isPresent))
    .map(map -> map
        .entrySet()
        .stream()
        .collect(toMap(
            Map.Entry::getKey,
            entry -> entry.getValue().get()
        ))
    );

这不是过于复杂 - 过滤和映射是流的用途!

以下方法完成工作:

Map<MyCoolKey, Optional<MyCoolValue>> input;
Optional<Map<MyCoolKey, MyCoolValue>> output = convertMapWithOptionals(input);

我想出了这种方法的两种“味道”:

1)不情愿:首先检查所有,然后开始转换

<K, V> Optional<Map<K, V>> convertMapWithOptionals(Map<K, Optional<V>> map) {
    if (!map.values().stream().allMatch(Optional::isPresent)) {
        return Optional.empty();
    }
    return Optional.of(map.entrySet().stream().collect(Collectors.toMap(
            Map.Entry::getKey, entry -> entry.getValue().get()
    )));
}

2)渴望:必要时开始转换和中止

<K, V> Optional<Map<K, V>> convertMapWithOptionals(Map<K, Optional<V>> map) {
    Map<K, V> result = new HashMap<>();
    for (Map.Entry<K, Optional<V>> entry : map.entrySet()) {
        if (!entry.getValue().isPresent()) {
            return Optional.empty();
        }
        result.put(entry.getKey(), entry.getValue().get());
    }
    return Optional.of(result);
}

如果我理解正确的问题,你可以使用reduce而不是collect 它允许您在收集期间更改accumulator

    Optional<Map<MyCoolKey, MyCoolValue>> optionalMap = myCoolMap
            .entrySet()
            .stream()
            .reduce(Optional.<Map<MyCoolKey, MyCoolValue>>of(new HashMap<>()),
                    (acc, entry) -> {
                        if (!acc.isPresent()) {
                            return acc;
                        }
                        if (!entry.getValue().isPresent()) {
                            return Optional.empty();
                        }
                        acc.get().put(entry.getKey(), entry.getValue().get());
                        return acc;
                    },
                    (acc, acc1) -> {
                        if (acc.isPresent() && acc1.isPresent()) {
                            acc.get().putAll(acc1.get());
                            return acc;
                        }
                        return Optional.empty();
                    }
            );

我认为你通过尝试将所有逻辑放在流中来过度复杂化。 只需过滤掉空的Optional s,看看元素的数量是否相同:

Optional<Map<MyCoolKey, MyCoolValue>> result = Optional.of(
    map.entrySet()
        .stream()
        .filter(e -> e.getValue().isPresent())
        .collect(
            Collectors.toMap(Map.Entry::getKey, e -> e.getValue().get())
        )
)
.filter(x-> x.size() == map.size());

暂无
暂无

声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.

 
粤ICP备18138465号  © 2020-2024 STACKOOM.COM