Question

在Collectors.toMap()期间找到重复的键条目时，会调用合并函数(o1, o2)。

问题：如何获取导致重复的密钥？

String keyvalp = "test=one\ntest2=two\ntest2=three";

Pattern.compile("\n")
    .splitAsStream(keyval)
    .map(entry -> entry.split("="))
    .collect(Collectors.toMap(
        split -> split[0],
        split -> split[1],
        (o1, o2) -> {
            //TODO how to access the key that caused the duplicate? o1 and o2 are the values only
            //split[0]; //which is the key, cannot be accessed here
        },
    HashMap::new));

在合并函数中，我想根据键决定，如果我取消映射，或继续并接受这些值。

Answer 1

您需要使用自定义收集器或使用其他方法。

private void Switchp_PreferenceChange(object sender, PreferenceChangeEventArgs e)
{
    var isenabled = (bool)e.NewValue;
    if (!isenabled)
    {
        var checkp = PreferenceScreen.FindPreference("Pref_battery_track_status") as CheckBoxPreference;
        checkp.Checked = false;
    }
}

编写自定义收集器相当复杂。你需要一个TriConsumer（键和两个值）是类似的，它不在JDK中，这就是为什么我很确定没有内置函数使用。 ;）

Answer 2

当你省略合并函数时，合并函数没有机会获取密钥，这是内置函数所具有的相同问题。

解决方案是使用不同的toMap实现，该实现不依赖于Map.merge：

public static <T, K, V> Collector<T, ?, Map<K,V>>
    toMap(Function<? super T, ? extends K> keyMapper,
          Function<? super T, ? extends V> valueMapper) {
    return Collector.of(HashMap::new,
        (m, t) -> {
            K k = keyMapper.apply(t);
            V v = Objects.requireNonNull(valueMapper.apply(t));
            if(m.putIfAbsent(k, v) != null) throw duplicateKey(k, m.get(k), v);
        },
        (m1, m2) -> {
            m2.forEach((k,v) -> {
                if(m1.putIfAbsent(k, v)!=null) throw duplicateKey(k, m1.get(k), v);
            });
            return m1;
        });
}
private static IllegalStateException duplicateKey(Object k, Object v1, Object v2) {
    return new IllegalStateException("Duplicate key "+k+" (values "+v1+" and "+v2+')');
}

^{（这基本上是没有合并功能的Java 9的toMap实现）}

因此，您需要在代码中执行的操作是重定向toMap调用并省略合并功能：

String keyvalp = "test=one\ntest2=two\ntest2=three";

Map<String, String> map = Pattern.compile("\n")
        .splitAsStream(keyvalp)
        .map(entry -> entry.split("="))
        .collect(toMap(split -> split[0], split -> split[1]));

（或ContainingClass.toMap如果它既不在同一类中也不在静态导入中）＆lt; \ sup＆gt;

收集器支持与原始toMap收集器类似的并行处理，但即使有更多要处理的元素，也不太可能从此处获得并行处理的好处。

如果我得到你的正确答案，你只想根据实际的密钥在合并函数中选择旧的或更新的值，你可以使用这样的密钥Predicate

public static <T, K, V> Collector<T, ?, Map<K,V>>
    toMap(Function<? super T, ? extends K> keyMapper,
          Function<? super T, ? extends V> valueMapper,
          Predicate<? super K> useOlder) {
    return Collector.of(HashMap::new,
        (m, t) -> {
            K k = keyMapper.apply(t);
            m.merge(k, valueMapper.apply(t), (a,b) -> useOlder.test(k)? a: b);
        },
        (m1, m2) -> {
            m2.forEach((k,v) -> m1.merge(k, v, (a,b) -> useOlder.test(k)? a: b));
            return m1;
        });
}

Map<String, String> map = Pattern.compile("\n")
        .splitAsStream(keyvalp)
        .map(entry -> entry.split("="))
        .collect(toMap(split -> split[0], split -> split[1], key -> condition));

有几种方法可以自定义此收集器...

Answer 3

当然，有一个简单而琐碎的技巧 - 在关键映射器中保存密钥＆＃39;在“合并”中获取功能并获取密钥功能。因此，代码可能如下所示（假设键是Integer）：

final AtomicInteger key = new AtomicInteger(); 
...collect( Collectors.toMap( 
   item -> { key.set(item.getKey()); return item.getKey(); }, // key mapper 
   item -> ..., // value mapper
   (v1, v2) -> { log(key.get(), v1, v2); return v1; } // merge function
);

注意：这不适合并行处理。

如何在Collectors.toMap合并函数中获取密钥？

3 个答案: