Odtnhj

I have following data set to represent sales record:

 sn| Channel | Category | Brand |qty | gross | 
 1 |"Mini Market" | "Large MM" | "ARIEL" |3 | 100 |
 2 |"Mini Market" | "Large MM" | "ARIEL" |6 | 200| 
 3 |"Mini Market" | "Large MM" | "GILLETTE" |12 | 103.88| 
 4 |"Mini Market" | "Large MM" | "OLAY" |2 | 50 | 
 5 |"Mini Market" | "Large MM" | "OLAY" |6 | 10| 
 6 |"Mini Market" | "Small MM" | "GILLETTE" |5 | 20 |
 7 |"Mini Market" | "Small MM" | "GILLETTE" |3 | 30| 
 8 |"Mini Market" | "Small MM" | "OLAY" |3 | 80.3 |
 9 |"Mini Market" | "Small MM" | "ORAL B" |6 | 100 |
 10|"Mini Market" | "Small MM" | "ORAL B" |7 | 150 |

POJO Classes:

class SalesRecord
 private String channel;
 private String category;
 private String brand;
 private int qty;
 private double gross;

 //getters and setters




class PivotTable 
 Map<Integer,Set<String>> uniqueAttirbuteMap;
 List<Pivot> pivot;
 //other fields and methods



class Pivot 
 public String attribute;
 Map<String, Double> aggregates;
 List<Pivot> pivotList;
 //other fields and methods

Custom Collector class:

public class SalesCollector implements Collector<SalesRecord,
 SalesCollector.Accumulator, PivotTable> 
 private static final String GROSS_SUM = "sum_gross";
 private static final String QTY_SUM = "sum_qty"

 public List<Double> prices = Lists.newArrayList();
 public List<Double> qtys = Lists.newArrayList();

 public double totalSales = 0;
 public double totalQty = 0;

 public SalesCollector(final List<GroupBy> groups) 
 this.groups = groups;
 


 @Override
 public Supplier<Accumulator> supplier() 
 return () -> new Accumulator(this.groups, this);
 

 @Override
 public BiConsumer<Accumulator, SalesRecord> accumulator() 
 return Accumulator::accumulate;
 

 @Override
 public BinaryOperator<Accumulator> combiner() 
 return Accumulator::combine;
 

 @Override
 public Function<Accumulator, PivotTable> finisher() 
 return Accumulator::toSummary;
 

 static class Accumulator 

 private final List<GroupBy> groups;
 private final SalesCollector collector;
 PivotTable pivotTable = new PivotTable();

 Accumulator(final List<GroupBy> groups, final SalesCollector collector) 
 this.groups = groups;
 this.collector = collector;
 

 void accumulate(SalesRecord elem) 
 double sum = pivotTable.getAggregates().getOrDefault(GROSS_SUM, 0D) + elem.getGross();
 pivotTable.getAggregates().put(GROSS_SUM, sum);

 double qtySum = pivotTable.getAggregates().getOrDefault(QTY_SUM, 0D) + elem.getQty();
 pivotTable.getAggregates().put(QTY_SUM, qtySum);
 

 Accumulator combine(Accumulator other) 

 final PivotTable summary = other.toSummary();

 double sum_qty =
 pivotTable.getAggregates().get(QTY_SUM) + summary.getAggregates().get(QTY_SUM);
 pivotTable.getAggregates().put(QTY_SUM, sum_qty);

 double sum_gross =
 pivotTable.getAggregates().get(GROSS_SUM) + summary.getAggregates().get(GROSS_SUM);
 pivotTable.getAggregates().put(GROSS_SUM, sum_gross);

 return this;
 

 PivotTable toSummary() 
 double sumGross = pivotTable.getAggregates().get(GROSS_SUM);
 collector.prices.add(sumGross);
 collector.totalSales += sumGross;


 double sumQty = pivotTable.getAggregates().get(QTY_SUM);
 collector.qtys.add(sumQty);
 collector.totalQty += sumQty;

 return pivotTable;
 
 

Currently I am using stream and gropuing and have a custom collector to calculate values for qty and gross as follows:

SalesCollector collector = new SalesCollector(groups);
 final Map<String, Map<String, Map<String, PivotTable>>> results = salesRecords.stream()
 .collect(groupingBy(SalesRecord::getChannel(), TreeMap::new,
 groupingBy(SalesRecord::getCategoryName(), TreeMap::new,
 groupingBy(SalesRecord::getBrand(), TreeMap::new, collector))));

List<PivotTable> myList = results.values().stream()
 .map(Map::values)
 .flatMap(Collection::stream)
 .map(Map::values)
 .flatMap(Collection::stream)
 .collect(Collectors.toList());

My current result is as follows:

PivotTable(pivot:[Pivot(attribute:Mini Market), Pivot(attribute:Large MM), Pivot(attribute:ARIEL, aggregates: sum_qty=9, sum_gross=300 )])
PivotTable(pivot:[Pivot(attribute:Mini Market), Pivot(attribute:Large MM), Pivot(attribute:GILLETTE, aggregates: sum_qty = 12, sum_gross= 103.88)])
PivotTable(pivot:[Pivot(attribute:Mini Market), Pivot(attribute:Large MM), Pivot(attribute:OLAY, aggregates: sum_qty = 8, sum_gross= 60)])
PivotTable(pivot:[Pivot(attribute:Mini Market), Pivot(attribute:Small MM), Pivot(attribute:OLAY, aggregates: sum_qty = 3, sum_gross= 80.3)])
PivotTable(pivot:[Pivot(attribute:Mini Market), Pivot(attribute:Small MM), Pivot(attribute:GILLETTE, aggregates: sum_qty = 8, sum_gross= 50)])
PivotTable(pivot:[Pivot(attribute:Mini Market), Pivot(attribute:Small MM), Pivot(attribute:ORAL B, aggregates: sum_qty = 13, sum_gross= 250)])

What I'm trying to achieve is as follows:

PivotTable(pivot:[Pivot(attribute:Mini Market), Pivot(attribute:Large MM), pivotList:[Pivot(attribute:ARIEL, aggregates: sum_qty=9, sum_gross=300 ),
Pivot(attribute:GILLETTE, aggregates: sum_qty = 12, sum_gross= 103.88),Pivot(attribute:OLAY, aggregates: sum_qty = 8, sum_gross= 60)])
PivotTable(pivot:[Pivot(attribute:Mini Market), Pivot(attribute:Small MM), Pivot(attribute:GILLETTE, aggregates: sum_qty = 8, sum_gross= 50)]),
Pivot(attribute:OLAY, aggregates: sum_qty = 3, sum_gross= 80.3),Pivot(attribute:ORAL B, aggregates: sum_qty = 13, sum_gross= 250)])

To put it simply, I want nesting as follows:

Mini Market:
 Large MM:
 ARIEL: sum_qty = 9, sum_gross= 300
 GILLETTE: sum_qty = 12, sum_gross= 103.88
 OLAY: sum_qty = 8, sum_gross= 60

Mini Market:
 Small MM:
 GILLETTE: sum_qty = 8, sum_gross= 50
 OLAY: sum_qty = 3, sum_gross= 80.3
 ORAL B: sum_qty = 13, sum_gross= 250

Is it possible to achive this with current collector result itself with same grouping? What would be best way to achieve this?

I extended your stream by the missing collector. It's a dedicated Collector which maps each SalesRecord to a Map<String, Double>. Since Map has one value type I decided to use Double.

 Supplier<Map<String, Double>> supplier = TreeMap::new;
 BiConsumer<Map<String, Double>, SalesRecord> biConsumer = (map, sr) -> 
 map.merge("sum_qty", Double.valueOf(sr.getQty()), (qtySum, qty) -> qtySum + qty);
 map.merge("sum_gross", sr.getGross(), (grossSum, gross) -> grossSum + gross);
 ;
 BinaryOperator<Map<String, Double>> binaryOperator = (l, r) -> 
 l.compute("sum_qty", (k, v) -> v + r.get("sum_qty"));
 l.compute("sum_gross", (k, v) -> v + r.get("sum_gross"));
 return l;
 ;
 Collector<SalesRecord, Map<String, Double>, Map<String, Double>> collector = Collector.of(supplier, biConsumer, binaryOperator);

Now addded as the last downstream collector to the stream:

Map<String, Map<String, Map<String, Map<String, Double>>>> grouped = salesRecords.stream().collect(Collectors.groupingBy(
 SalesRecord::getChannel, TreeMap::new,
 Collectors.groupingBy(SalesRecord::getCategory, TreeMap::new,
 Collectors.groupingBy(SalesRecord::getBrand, collector))));

The result is a Map<String, Map<String, Map<String, Map<String, Double>>>> grouped and looks like that (added line breaks for readability):

Mini Market= 
 Large MM=
 OLAY=sum_gross=60.0, sum_qty=8.0, 
 ARIEL=sum_gross=300.0, sum_qty=9.0,
 GILLETTE=sum_gross=103.88, sum_qty=12.0,
 Small MM=
 OLAY=sum_gross=80.3, sum_qty=3.0,
 ORAL B=sum_gross=250.0, sum_qty=13.0,
 GILLETTE=sum_gross=50.0, sum_qty=8.0