Как создать карту с различными значениями из карты (и использовать правильный ключ, используя BinaryOperator)?

13

У меня есть карта, Map<K, V>и моя цель состоит в том, чтобы удалить дублированные значения и Map<K, V>снова вывести ту же структуру . В случае дублируется значение найдено, то необходимо выбрать один ключ ( k) из двух клавиш ( k1и k1) , которые держат эти ценности, по этой причине, предположим , что BinaryOperator<K>дает kот k1и k2доступно.

Пример ввода и вывода:

// Input
Map<Integer, String> map = new HashMap<>();
map.put(1, "apple");
map.put(5, "apple");
map.put(4, "orange");
map.put(3, "apple");
map.put(2, "orange");

// Output: {5=apple, 4=orange} // the key is the largest possible

Моя попытка использования Stream::collect(Supplier, BiConsumer, BiConsumer)является немного очень неуклюжа и содержит изменяемые такие операции, как Map::putи Map::removeкоторые я хотел бы избежать:

// // the key is the largest integer possible (following the example above)
final BinaryOperator<K> reducingKeysBinaryOperator = (k1, k2) -> k1 > k2 ? k1 : k2;

Map<K, V> distinctValuesMap = map.entrySet().stream().collect(
    HashMap::new,                                                              // A new map to return (supplier)
    (map, entry) -> {                                                          // Accumulator
        final K key = entry.getKey();
        final V value = entry.getValue();
        final Entry<K, V> editedEntry = Optional.of(map)                       // New edited Value
            .filter(HashMap::isEmpty)
            .map(m -> new SimpleEntry<>(key, value))                           // If a first entry, use it
            .orElseGet(() -> map.entrySet()                                    // otherwise check for a duplicate
                    .stream() 
                    .filter(e -> value.equals(e.getValue()))
                    .findFirst()
                    .map(e -> new SimpleEntry<>(                               // .. if found, replace
                            reducingKeysBinaryOperator.apply(e.getKey(), key), 
                            map.remove(e.getKey())))
                    .orElse(new SimpleEntry<>(key, value)));                   // .. or else leave
        map.put(editedEntry.getKey(), editedEntry.getValue());                 // put it to the map
    },
    (m1, m2) -> {}                                                             // Combiner
);

Есть ли решение, использующее подходящую комбинацию Collectorsвнутри одного Stream::collectвызова (например, без изменяемых операций)?

Nikolas
источник
2
Каковы ваши показатели для « лучше » или « лучше »? Должно ли быть сделано через Streams?
Turing85
Если одно и то же значение связано с двумя ключами, как выбрать, какой ключ будет сохранен?
Майкл
Каковы ожидаемые результаты в вашем случае?
YCF_L
1
@ Turing85: Как я уже сказал. Лучше или лучше было бы, без явного использования изменяемых методов , таких как карты Map::putили в Map::removeпределах Collector.
Николай
1
На это стоит взглянуть BiMap. Возможно дубликат Удалить дубликаты значений из HashMap в Java
Наман

Ответы:

12

Вы можете использовать Collectors.toMap

private Map<Integer, String> deduplicateValues(Map<Integer, String> map) {
    Map<String, Integer> inverse = map.entrySet().stream().collect(toMap(
            Map.Entry::getValue,
            Map.Entry::getKey,
            Math::max) // take the highest key on duplicate values
    );

    return inverse.entrySet().stream().collect(toMap(Map.Entry::getValue, Map.Entry::getKey));
}
MikeFHay
источник
9

Попробуйте это: простой способ инвертировать ключ и значение, затем использовать toMap()коллектор с функцией слияния.

map.entrySet().stream()
        .map(entry -> new AbstractMap.SimpleEntry<>(entry.getValue(), entry.getKey()))
        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, reducingKeysBinaryOperator));

Map<K, V> output = map.entrySet().stream()
        .collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey, reducingKeysBinaryOperator))
        .entrySet().stream()
        .collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey));
Хади Дж
источник
2
Я не вижу, что mapпокупает промежуточная операция. Кажется, вы меняете ключи и значения, это понятно, но какой смысл, вы могли бы сделать это на этапе сбора?
GPI
3
@GPI и Майкл, это потому, что он должен объединить ключи, поэтому инвертирование пар объединит ключи. Чего не хватает, так это второй инверсии.
Жан-Батист Юнес
2
@ ХадиJ Нет! Инверсия была правильной! но второй был необходим, чтобы вернуться. Объединение используется для объединения ключей, но объединение возможно только для значений ...
Жан-Батист Юнес
@ Jean-BaptisteYunès Я понимаю необходимость слияния, но почему я не сразу понимаю, почему ты кодируешь swap(); collect(key, value, binOp);вместо collect(value, key, binOp). Может быть, мне нужно попробовать это в jshell по-настоящему?
GPI
2
Взял на себя смелость использовать локальную переменную, введенную в вопросе в общем для вас коде. Вернитесь в случае, если это противоречит намерению, пока вы делали ответ.
Наман
4

Я нахожу решение, не относящееся к потокам, более выразительным:

BinaryOperator<K> reducingKeysBinaryOperator = (k1, k2) -> k1 > k2 ? k1 : k2;

Map<V, K> reverse = new LinkedHashMap<>(map.size());
map.forEach((k, v) -> reverse.merge(v, k, reducingKeysBinaryOperator));

Map<K, V> result = new LinkedHashMap<>(reverse.size());
reverse.forEach((v, k) -> result.put(k, v));

Это используется Map.mergeс вашей двойной би-функцией и используется LinkedHashMapдля сохранения исходного порядка записей.

Федерико Перальта Шаффнер
источник
2
Да, я пришел к выводу об этом (аналогичном) решении. Тем не менее, я ищу подход java-stream , так как он более декларативный. Имейте +1
Николас
1

Я нашел способ использования только Collectorsбез необходимости повторного сбора и дальнейшей обработки возвращенной Карты. Идея заключается в следующем:

  1. Сгруппировать Map<K, V>в Map<V, List<K>.

    Map<K, V> distinctValuesMap = this.stream.collect(
        Collectors.collectingAndThen(
            Collectors.groupingBy(Entry::getValue),
            groupingDownstream 
        )
    );

    {яблоко = [1, 5, 3], апельсин = [4, 2]}

  2. Уменьшите новые ключи ( List<K>) для Kиспользования BinaryOperator<K>.

    Function<Entry<V, List<Entry<K, V>>>, K> keyMapFunction = e -> e.getValue().stream()
        .map(Entry::getKey)
        .collect(Collectors.collectingAndThen(
            Collectors.reducing(reducingKeysBinaryOperator),
            Optional::get
        )
    );

    {яблоко = 5, апельсин = 4}

  3. Инвертировать Map<V, K>обратно к Map<K, V>структуре снова - который является безопасным , так как ключи и значения гарантируются различными.

    Function<Map<V, List<Entry<K,V>>>, Map<K, V>> groupingDownstream = m -> m.entrySet()
        .stream()
        .collect(Collectors.toMap(
            keyMapFunction,
            Entry::getKey
        )
    );

    {5 = яблоко, 4 = апельсин}

Финальный код:

final BinaryOperator<K> reducingKeysBinaryOperator = ...

final Map<K, V> distinctValuesMap = map.entrySet().stream().collect(
        Collectors.collectingAndThen(
            Collectors.groupingBy(Entry::getValue),
            m -> m.entrySet().stream().collect(
                Collectors.toMap(
                    e -> e.getValue().stream().map(Entry::getKey).collect(
                        Collectors.collectingAndThen(
                            Collectors.reducing(reducingKeysBinaryOperator),
                            Optional::get
                        )
                    ),
                    Entry::getKey
                )
            )
        )
    );
Nikolas
источник
1

Другой подход, чтобы получить желаемый результат с «Stream and Collectors.groupingBy».

    map = map.entrySet().stream()
    .collect(Collectors.groupingBy(
            Entry::getValue,
            Collectors.maxBy(Comparator.comparing(Entry::getKey))
            )
    )
    .entrySet().stream()
    .collect(Collectors.toMap(
            k -> {
                return k.getValue().get().getKey();
            }, 
            Entry::getKey));
вишеш чандра
источник