Как создать карту карт из списка карт с потоковым API Java 8

Question

Фон

У меня есть список карт, который выглядит примерно так:

[
  {
    "name": "A",
    "old": 0.25,
    "new": 0.3
  },
  {
    "name": "B",
    "old": 0.3,
    "new": 0.35
  },
  {
    "name": "A",
    "old": 0.75,
    "new": 0.7
  },
  {
    "name": "B",
    "old": 0.7,
    "new": 0.60
  }
]

, и я хочу, чтобы вывод выглядел так:

{
  "A": {
    "old": 1,
    "new": 1
  },
  "B": {
    "old": 1,
    "new": 0.95
  }
}

... где значения old и new суммируются для каждой связанной записи.

Тип данных списка карт - List<Map<String, Object>>, поэтому на выходе должно быть Map<String, Map<String, Double>>.

Что я попробовал

С помощью некоторого чертежа диаграммы, чтения документации, проб и ошибок я смог придумать следующее:

data.stream()
    .collect(
        Collectors.groupingBy(entry -> entry.get("name"),
            Collectors.summingDouble(entry ->
                Double.parseDouble(entry.get("old").toString())))
    );

для производстваобъект типа Map<String, Double>, где на выходе получается

{
  "A": 1,
  "B": 1
}

для суммирования значений old.Тем не менее, я не могу преобразовать это в карту карт.Примерно так:

data.stream()
    .collect(
        Collectors.groupingBy(entry -> entry.get("name"),
            Collectors.mapping(
                Collectors.groupingBy(entry -> entry.get("old"),
                    Collectors.summingDouble(entry ->
                        Double.parseDouble(entry.get("old").toString())
                    )
                ),
                Collectors.groupingBy(entry -> entry.get("new"),
                    Collectors.summingDouble(entry ->
                        Double.parseDouble(entry.get("new").toString())
                    )
                )
            )
        )
    );

не работает, потому что Collectors.mapping() принимает только одну функцию отображения и нисходящий коллектор, но я не уверен, как отобразить два значения одновременно.

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

Answer 1

Этого можно достичь только с помощью инструментов Stream (аналогично this ):

Map<String, Map<String, Double>> collect = data.stream().collect(
    Collectors.groupingBy(m -> (String)m.get("name"),
    Collector.of(LinkedHashMap::new,
        (acc, e) -> Stream.of("old", "new").forEach(key -> acc.merge(key, (Double) e.get(key), Double::sum)),
        (m1, m2) -> {
          m2.forEach((k, v) -> m1.merge(k, v, Double::sum));
          return m1;
        })
    ));

---

Существует также способ> Java 8:

Map<String, Map<String, Double>> stats = data.stream().collect(
    Collectors.groupingBy(m -> (String) m.get("name"),
        Collectors.flatMapping(m -> m.entrySet().stream().filter(e -> !"name".equals(e.getKey())),
            Collectors.toMap(Map.Entry::getKey, e -> (Double)e.getValue(), Double::sum, LinkedHashMap::new)
        )
    ));

Answer 2

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

Вам понадобится реализовать собственный сборщик одна преобразует несколько карт в одну двойную карту.

Это выглядит следующим образом:

       Collector.of(
            () -> new HashMap<>(),
            (Map<String, Double>target, Map<String, Object> source) -> {
                target.merge("old", (Double)source.get("old"), Double::sum);
                target.merge("new", (Double)source.get("new"), Double::sum);
            },
            (Map<String, Double> map1, Map<String, Double> map2) -> {
                map2.forEach((k, v) -> map1.merge(k, v, Double::sum));
                return map1;
            }
        ) 

Это в сочетании с вашей первоначальной группировкой при попытке решает рисунок:

data.stream()
    .collect(
        Collectors.groupingBy(entry -> entry.get("name"),
            // Insert collector here
        )
    );

Пример полного кода онлайн: http://tpcg.io/pJftrJ

Answer 3

Вы можете использовать потоки, но вы также можете использовать Map 's computeIfAbsent и merge методы:

Map<String, Map<String, Double>> result = new LinkedHashMap<>();
data.forEach(entry -> {
    String name = (String) entry.get("name");
    Map<String, Double> map = result.computeIfAbsent(name, k -> new HashMap<>());
    map.merge("old", (Double) entry.get("old"), Double::sum);
    map.merge("new", (Double) entry.get("new"), Double::sum);
});

Answer 4

Вы можете объявить класс с именем Pair

public class Pair {
    private final double oldVal;
    private final double newVal;

    public Pair(double oldVal, double newVal) {
        super();
        this.oldVal = oldVal;
        this.newVal = newVal;
    }

    public double getOldVal() {
        return oldVal;
    }

    public double getNewVal() {
        return newVal;
    }

    @Override
    public String toString() {
        return "{oldVal=" + oldVal + ", newVal=" + newVal + "}";
    }

}

Затем сделайте это так,

Map<Object, Pair> result = sourceMaps.stream()
        .collect(Collectors.toMap(m -> m.get("name"),
                m -> new Pair((double) m.get("old"), (double) m.get("new")),
                (p1, p2) -> new Pair(p1.getOldVal() + p2.getOldVal(), p1.getNewVal() + p2.getNewVal())));

И вот вывод,

{A={oldVal=1.0, newVal=1.0}, B={oldVal=1.0, newVal=0.95}}