Подтвердить что ты не робот

Как получить ключ в функции слияния Collectors.toMap?

Если во время 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));

Внутри функции слияния я хочу решить на основе ключа, который, если я отменяю отображение, или продолжаю и принимаю эти значения.

Ответ 1

Вам нужно использовать пользовательский коллекционер или использовать другой подход.

Map<String, String> map = new Hashmap<>();
Pattern.compile("\n")
    .splitAsStream(keyval)
    .map(entry -> entry.split("="))
    .forEach(arr -> map.merge(arr[0], arr[1], (o1, o2) -> /* use arr[0]));

Написание пользовательского коллектора является более сложным. Вам нужен TriConsumer (ключ и два значения), аналогичный тому, который отсутствует в JDK, поэтому я уверен, что нет встроенной функции, которая использует.;)

Ответ 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 9s 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, если его нет ни в одном классе, ни в статическом импорте) <\sup >

Коллекционер поддерживает параллельную обработку, такую как исходный сборщик 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));

Существует несколько способов настройки этого коллектора...

Ответ 3

Существует, конечно, простой и тривиальный трюк - сохранение ключа в функции "key mapper" и получение ключа в функции "merge". Таким образом, код может выглядеть следующим образом (при условии, что ключ 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
);

Примечание: это не подходит для параллельной обработки.