Java使用流按月获取订购产品的数量

我想准备一份简单的报告，按月份显示订购产品的数量，如下所示（降序）：

我的数据：

  class Orders {

        private List<Order> orders = new ArrayList<>();

        public void prepareData() {

            Product socks = new ProductBuilder()
                    .setPrice(new BigDecimal("23"))
                    .setCategory(Category.C)
                    .setName("SOCKS")
                    .build();

            Product jacket = new ProductBuilder()
                    .setPrice(new BigDecimal("199"))
                    .setCategory(Category.A)
                    .setName("JACKET")
                    .build();

            Product watch = new ProductBuilder()
                    .setPrice(new BigDecimal("100"))
                    .setCategory(Category.B)
                    .setName("WATCH CASIO")
                    .build();


            Customer john = new CustomerBuilder()
                    .setAge(18)
                    .setName("JOHN")
                    .setSurname("JOHNSON")
                    .setEmail("john@johnson.com")
                    .build();

            Customer mike = new CustomerBuilder()
                    .setAge(20)
                    .setName("MIKE")
                    .setSurname("MAX")
                    .setEmail("mike@max.com")
                    .build();


            Order orderJohn = new OrderBuilder()
                    .setQuantity(2)
                    .setCustomer(john)
                    .setProduct(watch)
                    .setOrderDate(LocalDate.now())
                    .build();

            Order orderJohn2 = new OrderBuilder()
                    .setQuantity(4)
                    .setCustomer(john)
                    .setProduct(socks)
                    .setOrderDate(LocalDate.now())
                    .build();


             Order orderMike = new OrderBuilder()
                    .setQuantity(2)
                    .setCustomer(mike)
                    .setProduct(jacket)
                    .setOrderDate(LocalDate.now())
                    .build();

            orders.add(orderJohn);
            orders.add(orderJohn2);


            orders.add(orderMike);
    }
}

但如何按月增加产品数量<代码>数量订单中的字段类

public class Order {

    private Customer customer;
    private Product product;
    private int quantity;
    private LocalDate orderDate;
   //get/set
}

public class Customer {

    private String name;
    private String surname;
    private int age;
    private String email;
    //get/set
}

public class Product {
    private String name;
    private BigDecimal price;
    private Category category;
    //get/set
}

建筑商

public class CustomerBuilder {

    private Customer customer = new Customer();

    public CustomerBuilder setName(String name){
        customer.setName(name);
        return this;
    }

    public CustomerBuilder setSurname(String surname){
        customer.setSurname(surname);
        return this;
    }

    public CustomerBuilder setAge(int age){
        customer.setAge(age);
        return this;
    }

    public CustomerBuilder setEmail(String email){
        customer.setEmail(email);
        return this;
    }

    public Customer build()  {

        return customer;
    }

}
public class OrderBuilder {
   private Order order = new Order();

   public OrderBuilder setCustomer(Customer customer){
       order.setCustomer(customer);
       return this;
   }

   public OrderBuilder setProduct(Product product){
       order.setProduct(product);
       return this;
   }

   public OrderBuilder setQuantity(int quantity){
       order.setQuantity(quantity);
       return this;
   }

   public OrderBuilder setOrderDate(LocalDate orderDate){
       order.setOrderDate(orderDate);
       return this;
   }

   public Order build(){
       return order;
   }

}

public class ProductBuilder {

    private Product product = new Product();

    public ProductBuilder setCategory(Category category){
        product.setCategory(category);
        return this;
    }

    public ProductBuilder setName(String name){
        product.setName(name);
        return this;
    }

    public ProductBuilder setPrice(BigDecimal bigDecimal){
        product.setPrice(bigDecimal);
        return this;
    }

    public Product build() {
        return product;
    }
}

---

使用

Collectors.summingit（Order:：getQuantity）

而不是

Collectors.counting（）

使用

Collectors.summingit（Order:：getQuantity）

而不是

Collectors.counting（）

您可以将

收集器.counting（）

替换为：

Collectors.summingInt(Order::getQuantity)

（其工作原理如下：

收集器。减少（0，Order:：getQuantity，Integer:：sum）

）

编辑：

看看你对另一个答案的评论，以下是你需要的：

Map<LocalDate, IntSummaryStatistics> ord = orders.stream().collect(Collectors.groupingBy(e -> e.getOrderDate().withDayOfMonth(1), Collectors.summarizingInt(Order::getQuantity)));
ord.entrySet().stream().sorted(Map.Entry.comparingByValue((p1,p2) -> Long.compare(p2.getSum(), p1.getSum()))).forEach(System.out::println);

Map Order=orders.stream（）.collect（Collectors.groupingBy（e->e.getOrderDate（）.withDayOfMonth（1），Collectors.summaringit（Order:：getQuantity））；
ord.entrySet（）.stream（）.sorted（Map.Entry.comparingByValue（（p1，p2）->Long.compare（p2.getSum（），p1.getSum（）））.forEach（System.out:：println）；

您可以将

收集器.counting（）替换为：

Collectors.summingInt(Order::getQuantity)

（其工作原理如下：
收集器。减少（0，Order:：getQuantity，Integer:：sum）
）

编辑：

看看你对另一个答案的评论，以下是你需要的：

Map<LocalDate, IntSummaryStatistics> ord = orders.stream().collect(Collectors.groupingBy(e -> e.getOrderDate().withDayOfMonth(1), Collectors.summarizingInt(Order::getQuantity)));
ord.entrySet().stream().sorted(Map.Entry.comparingByValue((p1,p2) -> Long.compare(p2.getSum(), p1.getSum()))).forEach(System.out::println);

Map Order=orders.stream（）.collect（Collectors.groupingBy（e->e.getOrderDate（）.withDayOfMonth（1），Collectors.summaringit（Order:：getQuantity））；
ord.entrySet（）.stream（）.sorted（Map.Entry.comparingByValue（（p1，p2）->Long.compare（p2.getSum（），p1.getSum（）））.forEach（System.out:：println）；
yes我这样做
Map Order=orders.stream（）.collect（收集器.groupingBy（e->e.getOrderDate（）.withDayOfMonth（1），收集器.summaringit（Order:：getQuantity））；ord.entrySet（）.stream（）.sorted（Comparator.comparingLong（p->p.getValue（）.getSum（））但如何颠倒顺序？是的，我这样做
Map order=orders.stream（）.collect（收集器.groupingBy（e->e.getOrderDate（）.withDayOfMonth（1），收集器.SummaringIT（order:：getQuantity））；ord.entrySet（）.stream（）.sorted（Comparator.comparingLong（p->p.getValue（）.getSum（））但如何颠倒顺序？请邮寄。对于所问的问题，不需要那么多代码（但不是可执行的）。@lukassz查看我编辑的答案，请发布。对于所问的问题，不需要那么多代码（但不可执行）。@lukassz看到我编辑的答案了吗？我还有另一个问题，如何按月份获得最受欢迎的类别？请检查其中一个答案，但将其与
Collectors.maxBy（）
一起使用。我正试图以这种方式执行
orders.stream（）.collector（Collectors.groupingBy>）（e->e.getOrderDate（）.withDayOfMonth（1））.entrySet（）.stream（）.collect（Collectors.groupingBy（Product:：getCategory，Collectors.counting（）））；
但我有一个问题，我有另一个问题，如何按月份获取最受欢迎的类别？请检查答案之一，但将其与
收集器.maxBy（）
一起使用。我正试图以这种方式执行
orders.stream（）.collect（收集器.groupingBy（e->e.getOrderDate（）.withdayofmon（1））.entrySet（）.stream（）.collect（Collectors.groupingBy（Product:：getCategory，Collectors.counting（））；
但我发现了一个错误