Java 8分组为对象集合

Question

我想在到期日对一个Retrient对象集合进行分组，但我想为每个组创建一个新的RentalReport对象，其中键是预定义的值（枚举），并且组是该对象的属性。我通过根据每个条件拟合集合并为每个条件创建一个RentalReport对象来实现这一点，但我想知道是否可以使用Collectors类的groupingBy方法来实现这一点。

有没有可能在Java 8中按一组预定义的过滤器进行分组，这样我就可以创建一个映射，其中键是枚举，值是租赁对象的集合。然后我可以迭代这个映射并生成RentalReport对象。

我已经创建了这个演示，但真正的任务涉及多个group by子句，所以如果我可以通过分组来实现这一点就太好了。

    import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import org.joda.time.DateTime;

public class TestGrouping {

    enum RentalClassification {
        UNRESTRICTED, //No restriction restricted=false
        OVERDUE,      //todays date after due date.
        NEARLY_OVERDUE, // todays date after due date + 2 days
        NOT_OVERDUE
    }

    public static void main(String[] args) {

        class Rental {
            Integer rentalId;
            Integer productId;
            boolean restricted;
            DateTime dueDate;

            public Rental(Integer rentalId, Integer productId, boolean restricted, DateTime dueDate){
                this.rentalId = rentalId;
                this.productId = productId;
                this.restricted = restricted;
                this.dueDate = dueDate;
            }

            public Integer getRentalId() {
                return rentalId;
            }

            public void setRentalId(Integer rentalId) {
                this.rentalId = rentalId;
            }

            public Integer getProductId() {
                return productId;
            }

            public void setProductId(Integer productId) {
                this.productId = productId;
            }

            public boolean isRestricted() {
                return restricted;
            }

            public void setRestricted(boolean restricted) {
                this.restricted = restricted;
            }

            public DateTime getDueDate() {
                return dueDate;
            }

            public void setDueDate(DateTime dueDate) {
                this.dueDate = dueDate;
            }

            public String toString(){
                return "RentalId:"+this.rentalId+". ProductId:"+this.productId+". Due date:"+this.dueDate+". -";
            }
        }

        class RentalReport {

            RentalClassification classification;
            List<Rental> rentals;

            public RentalReport(RentalClassification classification, List<Rental> rentals) {
                this.classification = classification;
                this.rentals = rentals;
            }

            public RentalClassification getClassification() {
                return classification;
            }
            public void setClassification(RentalClassification classification) {
                this.classification = classification;
            }
            public List<Rental> getRentals() {
                return rentals;
            }
            public void setRentals(List<Rental> rentals) {
                this.rentals = rentals;
            }

            public String toString(){
                StringBuilder sb = new StringBuilder("Classification:"+this.classification.name()+". Rental Ids:");
                this.rentals.forEach(r -> sb.append(r.getRentalId()));
                return sb.toString();

            }

        }

        DateTime today = new DateTime();

        List<Rental> rentals = Arrays.asList(
                new Rental(1,100, true, today.plusDays(-10)),
                new Rental(2,101, false, today.plusDays(-10)),
                new Rental(3,102, true, today.plusDays(-4)),
                new Rental(4,103, true, today.plusDays(-4)),
                new Rental(5,104, true, today.plusDays(-4)),
                new Rental(6,105, true, today.plusDays(2)),
                new Rental(7,106, true, today.plusDays(2)),
                new Rental(8,107, true, today.plusDays(2)),
                new Rental(9,108, true, today.plusDays(4)),
                new Rental(10,109, true, today.plusDays(5))
                );


        List<RentalReport> rentalReports = new ArrayList<RentalReport>();

        List<Rental> unrestrictedRentals = rentals.stream()
                                           .filter(r -> !r.isRestricted())
                                           .collect(Collectors.toList());

        rentalReports.add(new RentalReport(RentalClassification.UNRESTRICTED, unrestrictedRentals));

        List<Rental> overdueRentals = rentals.stream()
                                      .filter(r -> r.isRestricted() && r.getDueDate().isBefore(new DateTime()))
                                      .collect(Collectors.toList());

        rentalReports.add(new RentalReport(RentalClassification.OVERDUE, overdueRentals));

        List<Rental> nearlyOverdueRentals = rentals.stream()
                                            .filter(r -> r.isRestricted() 
                                                    && r.getDueDate().isAfter(new DateTime())
                                                    && r.getDueDate().isBefore(new DateTime().plusDays(2)))
                                            .collect(Collectors.toList());

        rentalReports.add(new RentalReport(RentalClassification.NEARLY_OVERDUE, nearlyOverdueRentals));

        List<Rental> notOverdueRentals = rentals.stream()
                                        .filter(r -> r.isRestricted() && r.getDueDate().isAfter(new DateTime()))
                                        .collect(Collectors.toList());

        rentalReports.add(new RentalReport(RentalClassification.NOT_OVERDUE, notOverdueRentals));

        System.out.println("Rental Reports: "+rentalReports.toString());

    }
    }

Answer 1

来点这样的怎么样：

rentals.stream().collect(Collectors.groupingBy(r -> {
    if (!r.isRestricted()) {
        return RentalClassification.UNRESTRICTED;
    }
    if (r.isRestricted() && r.getDueDate().isBefore(new DateTime())) {
        return RentalClassification.OVERDUE;
    }
    // and so on
}));

可能还值得将lambda作为方法RentalClassificationgetRentalClassification()添加到Retric中