Question

У меня есть следующий набор данных для представления записи о продажах:

 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 Классы:

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

}

Пользовательский класс сборщика:

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;
        }
    }
}

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

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());

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

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})])

Что я пытаюсьДостигается следующее:

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})])

Проще говоря, я хочу вложиться следующим образом:

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}

Можно ли добиться этого с самим результатом коллектора тока с той же группировкой?Каков наилучший способ добиться этого?

LuCio · Answer 1 · 14 ноября 2018

Я расширил ваш поток пропавшим collector.Это выделенный Collector, который отображает каждый SalesRecord на Map<String, Double>.Поскольку Map имеет один тип значения, я решил использовать 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);

Теперь добавлен как последний нисходящий коллектор в поток:

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))));

В результате получается Map<String, Map<String, Map<String, Map<String, Double>>>> grouped и выглядит так (добавлены разрывы строк для удобства чтения):

{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}}
                }
}

Вложенные Значения с потоком и сборщиком Java 8

Пожалуйста, войдите или зарегистрируйтесь чтобы ответить на этот вопрос.

1 Ответ

Пожалуйста, войдите или зарегистрируйтесь что бы добавить комментарий.

Вложенные Значения с потоком и сборщиком Java 8

Пожалуйста, войдите или зарегистрируйтесь чтобы ответить на этот вопрос.

1 Ответ

Пожалуйста, войдите или зарегистрируйтесь что бы добавить комментарий.

Похожие темы