Question

我有一个我想要转换和过滤的Java Map。作为一个简单的例子，假设我想将所有值转换为整数，然后删除奇数条目。

Map<String, String> input = new HashMap<>();
input.put("a", "1234");
input.put("b", "2345");
input.put("c", "3456");
input.put("d", "4567");

Map<String, Integer> output = input.entrySet().stream()
        .collect(Collectors.toMap(
                Map.Entry::getKey,
                e -> Integer.parseInt(e.getValue())
        ))
        .entrySet().stream()
        .filter(e -> e.getValue() % 2 == 0)
        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));


System.out.println(output.toString());

这是正确的，并产生：{a=1234, c=3456}

然而，我不禁想知道是否有办法避免两次致电.entrySet().stream()。

有没有办法可以执行转换和过滤操作，最后只调用.collect()一次？

Answer 1

是的，您可以将每个条目映射到另一个临时条目，该条目将保存密钥和解析的整数值。然后，您可以根据其值过滤每个条目。

Map<String, Integer> output =
    input.entrySet()
         .stream()
         .map(e -> new AbstractMap.SimpleEntry<>(e.getKey(), Integer.valueOf(e.getValue())))
         .filter(e -> e.getValue() % 2 == 0)
         .collect(Collectors.toMap(
             Map.Entry::getKey,
             Map.Entry::getValue
         ));

请注意，我使用的是Integer.valueOf而不是parseInt，因为我们实际上需要一个盒装的int。

如果您有幸使用StreamEx库，可以非常简单地完成：

Map<String, Integer> output =
    EntryStream.of(input).mapValues(Integer::valueOf).filterValues(v -> v % 2 == 0).toMap();

Answer 2

以较小的开销解决问题的一种方法是将映射和过滤下移到收集器。

Map<String, Integer> output = input.entrySet().stream().collect(
    HashMap::new,
    (map,e)->{ int i=Integer.parseInt(e.getValue()); if(i%2==0) map.put(e.getKey(), i); },
    Map::putAll);

这不需要创建中间Map.Entry实例，甚至更好，将int值的装箱推迟到值Map实际添加到Collectors.toMap(…)时意味着过滤器拒绝的值根本没有装箱。

与Map.put所做的相比，我们事先知道我们不必处理关键冲突，因此使用Map.merge而不是HashMap<String,Integer> output=new HashMap<>(); for(Map.Entry<String, String> e: input.entrySet()) { int i = Integer.parseInt(e.getValue()); if(i%2==0) output.put(e.getKey(), i); }也简化了操作。

但是，只要您不想使用并行执行，您也可以考虑普通循环

HashMap<String,Integer> output=new HashMap<>();
input.forEach((k,v)->{ int i = Integer.parseInt(v); if(i%2==0) output.put(k, i); });

或内部迭代变体：

MainWindow.xaml.cs

后者非常紧凑，至少与所有其他有关单线程性能的变体相同。

Answer 3

Guava是你的朋友：

Map<String, Integer> output = Maps.filterValues(Maps.transformValues(input, Integer::valueOf), i -> i % 2 == 0);

请注意，output是input的已转换，已过滤的视图。如果你想独立操作它们，你需要制作一份副本。

Answer 4

您可以使用Stream.collect(supplier, accumulator, combiner)方法转换条目并有条件地累积它们：

Map<String, Integer> even = input.entrySet().stream().collect(
    HashMap::new,
    (m, e) -> Optional.ofNullable(e)
            .map(Map.Entry::getValue)
            .map(Integer::valueOf)
            .filter(i -> i % 2 == 0)
            .ifPresent(i -> m.put(e.getKey(), i)),
    Map::putAll);

System.out.println(even); // {a=1234, c=3456}

这里，在累加器中，我使用Optional方法来应用转换和谓词，如果可选值仍然存在，我将它添加到正在收集的地图中。 / p>

Answer 5

另一种方法是从已转换的Map中删除您不想要的值：

Map<String, Integer> output = input.entrySet().stream()
        .collect(Collectors.toMap(
                Map.Entry::getKey,
                e -> Integer.parseInt(e.getValue()),
                (a, b) -> { throw new AssertionError(); },
                HashMap::new
         ));
output.values().removeIf(v -> v % 2 != 0);

这假设你想要一个可变的Map作为结果，如果不是，你可以从output创建一个不可变的。{/ p>

如果您要将值转换为相同的类型并希望修改Map，那么replaceAll可能会更短：

input.replaceAll((k, v) -> v + " example");
input.values().removeIf(v -> v.length() > 10);

这也假设input是可变的。

我不建议这样做，因为它不适用于所有有效的Map实施，并且可能在将来停止为HashMap工作，但您目前可以使用replaceAll并投HashMap更改值的类型：

((Map)input).replaceAll((k, v) -> Integer.parseInt((String)v));
Map<String, Integer> output = (Map)input;
output.values().removeIf(v -> v % 2 != 0);

这也会为您提供类型安全警告，如果您尝试通过旧类型的引用从Map检索值，如下所示：

String ex = input.get("a");

它将抛出ClassCastException。

如果您希望使用它，可以将第一个变换部分移动到避免样板的方法中：

public static <K, VO, VN, M extends Map<K, VN>> M transformValues(
        Map<? extends K, ? extends VO> old, 
        Function<? super VO, ? extends VN> f, 
        Supplier<? extends M> mapFactory){
    return old.entrySet().stream().collect(Collectors.toMap(
            Entry::getKey, 
            e -> f.apply(e.getValue()), 
            (a, b) -> { throw new IllegalStateException("Duplicate keys for values " + a + " " + b); },
            mapFactory));
}

并像这样使用它：

    Map<String, Integer> output = transformValues(input, Integer::parseInt, HashMap::new);
    output.values().removeIf(v -> v % 2 != 0);

请注意，例如，old Map为IdentityHashMap且mapFactory创建HashMap时，可能会引发重复键异常。

Answer 6

以下是AbacusUtil

的代码

Map<String, String> input = N.asMap("a", "1234", "b", "2345", "c", "3456", "d", "4567");

Map<String, Integer> output = Stream.of(input)
                          .groupBy(e -> e.getKey(), e -> N.asInt(e.getValue()))
                          .filter(e -> e.getValue() % 2 == 0)
                          .toMap(Map.Entry::getKey, Map.Entry::getValue);

N.println(output.toString());

声明：我是AbacusUtil的开发者。

使用流转换和过滤Java Map

6 个答案: