如何从 Set/Map 中删除多个元素并知道哪些元素已被删除？

Question

我有一个方法必须从一些（可能很大）Map<K,V> from 中删除（小）Set<K> keysToRemove 中列出的任何元素。但是removeAll() 不行，因为我需要返回所有实际删除的键，因为地图可能包含也可能不包含需要删除的键。

老派代码直截了当：

public Set<K> removeEntries(Map<K, V> from) {
    Set<K> fromKeys = from.keySet();
    Set<K> removedKeys = new HashSet<>();
    for (K keyToRemove : keysToRemove) {
        if (fromKeys.contains(keyToRemove)) {
            fromKeys.remove(keyToRemove);
            removedKeys.add(keyToRemove);
        }
    }
    return removedKeys;
}

同样，使用流编写：

Set<K> fromKeys = from.keySet();
return keysToRemove.stream()
        .filter(fromKeys::contains)
        .map(k -> {
            fromKeys.remove(k);
            return k;
        })
        .collect(Collectors.toSet());

我觉得这更简洁一些，但我也觉得 lambda 太笨重了。

有什么建议可以以不那么笨拙的方式实现相同的结果吗？

Answer 1

“老派代码”应该是

public Set<K> removeEntries(Map<K, ?> from) {
    Set<K> fromKeys = from.keySet(), removedKeys = new HashSet<>(keysToRemove);
    removedKeys.retainAll(fromKeys);
    fromKeys.removeAll(removedKeys);
    return removedKeys;
}

既然你说keysToRemove 相当小，那么复制开销可能并不重要。否则，使用循环，但不要进行两次哈希查找：

public Set<K> removeEntries(Map<K, ?> from) {
    Set<K> fromKeys = from.keySet();
    Set<K> removedKeys = new HashSet<>();
    for(K keyToRemove : keysToRemove)
        if(fromKeys.remove(keyToRemove)) removedKeys.add(keyToRemove);
    return removedKeys;
}

您可以将相同的逻辑表达为流

public Set<K> removeEntries(Map<K, ?> from) {
    return keysToRemove.stream()
        .filter(from.keySet()::remove)
        .collect(Collectors.toSet());
}

但由于这是一个有状态的过滤器，因此强烈建议不要这样做。一个更干净的变体是

public Set<K> removeEntries(Map<K, ?> from) {
    Set<K> result = keysToRemove.stream()
        .filter(from.keySet()::contains)
        .collect(Collectors.toSet());
    from.keySet().removeAll(result);
    return result;
}

如果你想最大化“流式”的使用，你可以用from.keySet().removeIf(result::contains)替换from.keySet().removeAll(result);，因为它正在迭代更大的地图，或者result.forEach(from.keySet()::remove)，它不会有这个缺点，但仍然没有比removeAll 更具可读性。

总而言之，“老派代码”要好得多。

Answer 2

更简洁的解决方案，但在filter 调用中仍然存在不需要的副作用：

Set<K> removedKeys =
    keysToRemove.stream()
                .filter(fromKeys::remove)
                .collect(Collectors.toSet());

如果set 包含指定的元素，Set.remove 已经返回true。

最后，我可能会坚持使用“老式代码”。

Answer 3

我不会为此使用 Streams。我会利用retainAll：

public Set<K> removeEntries(Map<K, V> from) {
    Set<K> matchingKeys = new HashSet<>(from.keySet());
    matchingKeys.retainAll(keysToRemove);

    from.keySet().removeAll(matchingKeys);

    return matchingKeys;
}

Answer 4

你可以使用流和removeAll

Set<K> fromKeys = from.keySet();
Set<K> removedKeys = keysToRemove.stream()
    .filter(fromKeys::contains)
    .collect(Collectors.toSet());
fromKeys.removeAll(removedKeys);
return removedKeys;

Answer 5

你可以用这个：

Set<K> removedKeys = keysToRemove.stream()
        .filter(from::containsKey)
        .collect(Collectors.toSet());
removedKeys.forEach(from::remove);

这类似于 Oleksandr 的回答，但避免了副作用。但是，如果您正在寻找性能，我会坚持这个答案。

或者，您可以使用Stream.peek() 进行删除，但要小心其他副作用（请参阅 cmets）。所以我不建议这样做。

Set<K> removedKeys = keysToRemove.stream()
        .filter(from::containsKey)
        .peek(from::remove)
        .collect(Collectors.toSet());

Answer 6

要向方法添加另一种变体，还可以对键进行分区并将所需的Set 返回为：

public Set<K> removeEntries(Map<K, ?> from) {
    Map<Boolean, Set<K>> partitioned = keysToRemove.stream()
            .collect(Collectors.partitioningBy(k -> from.keySet().remove(k),
                    Collectors.toSet()));
    return partitioned.get(Boolean.TRUE);
}