Calculate sum of list within a Map of Map

I have a list of Trades that is a map of map grouped by Region and Status. Trade class has an attribute amount field.

Map<Region, Map<Status, List<Trade>>> groupedTrades

class Trade {
  double amount;
}

I want to group the amounts across Trades within the list and return it as below

Map<Region, Map<Status, Double>> sumOfGroupedTradeAmounts

Double is a sum of all the amount fields within the list of trades.

How can I do this is in java8?

You can do it like this. Basically, you are:

• Doing nested streaming of the entrySets.
• Stream the outer map entries to get the inner map values and the outer map key.
• in the inner entry set, stream the value, which is the List<Doubles> and sum them.
• these are then returned in the specified map using the outer map key, inner map key and a sum of the Trade amounts resulting in a double value.

Note that I added a getter to the Trade class for amount retrieval.

class Trade {
	double amount;
	
	public double getAmount() {
		return amount;
	}
}
	
public static void main(String[] args) {
	Map<Region, Map<Status, Double>> result = groupedTrades
			.entrySet().stream()

            // outer map starts here, keying on Region
			.collect(Collectors.toMap(Entry::getKey, e -> e
					.getValue().entrySet().stream()

                     // inner map starts here, keying on Status
					.collect(Collectors.toMap(Entry::getKey,

                           // stream the list and sum the amounts.
							ee -> ee.getValue().stream()
									.mapToDouble(Trade::getAmount)
									.sum()))));
	
}

Given the following structure where Region and Status are numbers and letters respectively,

Map<Region, Map<Status, List<Trade>>> groupedTrades = Map.of(   
		new Region(1),                                          
		Map.of(new Status("A"),                                 
				List.of(new Trade(10), new Trade(20),           
						new Trade(30)),                         
				new Status("B"),                                
				List.of(new Trade(1), new Trade(2))),           
		new Region(2),                                          
		Map.of(new Status("A"),                                 
				List.of(new Trade(2), new Trade(4),             
						new Trade(6)),                          
				new Status("B"), List.of(new Trade(3),          
						new Trade(6), new Trade(9))));

result.forEach((k, v) -> {                           
	System.out.println(k);                           
	v.forEach((kk, vv) -> System.out                 
			.println("     " + kk + " -> " + vv));   
});                                                            

Here is the sample output.

2
     B -> 18.0
     A -> 12.0
1
     B -> 3.0
     A -> 60.0

If you're interested in suming all of the values. you can do it as follows by using the just created nested map of doubles.

double allSums =
         // Stream the inner maps 
         result.values().stream()
         // put all the Doubles in a single stream
		.flatMap(m->m.values().stream())
         // unbox the Doubles to primitive doubles
		.mapToDouble(Double::doubleValue)
         // and sum them
        .sum();

</details>



# 答案2
**得分**: 0

仅使用流，可能如下所示：

```java
Map<Region, Map<Status, Double>> result =
    groupedTrades
        .entrySet()
        .stream()
        .collect(Collectors.toMap(
                 Map.Entry::getKey, // 保留键不变
                 entry -> mapToDouble(entry.getValue(), MyClass::sumOfTrades))); // 应用 sumOfTrades（见下文）

我们定义一个小辅助函数，以保持流的可读性：

// 接受包含交易列表的映射，并应用函数映射器，在这些列表上返回 T（可能为 double）
private static <T> Map<Status, T> mapToDouble(Map<Status, List<Trade>> trades, Function<List<Trade>, T> mapper) {
    return trades.entrySet()
            .stream()
            .collect(Collectors.toMap(
                    Map.Entry::getKey, // 保留键不变
                    entry -> mapper.apply(entry.getValue())));
}

// 接受交易列表并返回其总和
private static double sumOfTrades(List<Trade> trades) {
    return trades.stream().mapToDouble(Trade::getAmount).sum();
}

额外内容 - 所有交易的总和：

double sum =
    groupedTrades
        // 获取“内部”映射的集合
        .values()
        .stream()
        // 仅获取它们的值作为列表集合
        .map(Map::values)
        // 将集合映射为列表的流
        .flatMap(Collection::stream)
        // 将列表流映射为交易值的流
        .flatMap(Collection::stream)
        // 将交易映射为 double 值 - “amount”
        .mapToDouble(Trade::getAmount)
        // 获取总和
        .sum();

Map<Region, Map<Status, Double>> result =
    groupedTrades
        .entrySet()
        .stream()
        .collect(Collectors.toMap(
                 Map.Entry::getKey, // Leave key as is
                 entry -> mapToDouble(entry.getValue(), MyClass::sumOfTrades))); // applies sumOfTrades (See below)

// Takes map which contains lists of trades and and applies function mapper, which returns T (might be double) on those lists
private static <T> Map<Status, T> mapToDouble(Map<Status, List<Trade>> trades, Function<List<Trade>, T> mapper) {
    return trades.entrySet()
            .stream()
            .collect(Collectors.toMap(
                    Map.Entry::getKey, // Leave key as is
                    entry -> mapper.apply(entry.getValue())));
}

// Takes a list of trades and returns its sum
private static double sumOfTrades(List<Trade> trades) {
    return trades.stream().mapToDouble(Trade::getAmount).sum();
}

double sum =
    groupedTrades
        // get collection of "inner" maps
        .values()
        .stream()
        // get only their values as collection of lists 
        .map(Map::values)
        // map the collection into stream of lists
        .flatMap(Collection::stream)
        // map the collection stream of lists into stream of Trade values
        .flatMap(Collection::stream)
        // map Trade into double value - "amount"
        .mapToDouble(Trade::getAmount)
        // get the sum
        .sum();