Java 按枚举类型筛选集合

我创建了一个期限跟踪器来管理一个人在一段时间内的工作量

“截止日期跟踪器”将问题分为“工作负载周期”，这些是共享同一截止日期的问题集合。期间的状态为enum类型，可以是未计划、未来、冻结或过期

但是，我遇到了一个问题，即如果只有一些问题处于冻结状态，则WorkloadPeriods被定义为“处于冻结状态”。每个问题都有一个冻结长度、截止日期和截止状态

我想将这些“冻结”问题分为一个单独的工作负载周期。如何按deadlineDate和deadlineStatus筛选问题以阻止此问题的发生

public static class WorkloadPeriod implements Comparable<WorkloadPeriod>
{
    private final LocalDate start;

    @Nullable
    private final LocalDate deadline;

    private final SortedSet<Issue> issues = new TreeSet<>();

    private DeadlineStatus deadlineStatus;

    private Stream inFreeze;

    public WorkloadPeriod(final LocalDate start, final Iterable<Issue> issues)
    {
        this.start = start;
        deadline = StreamSupport.stream(issues.spliterator(), false)
                                .map(Issue::getDeadline)
                                .filter(Optional::isPresent)
                                .map(Optional::get)
                                .max(Ordering.natural())
                                .orElse(null);
        inFreeze = StreamSupport.stream(issues.spliterator(), false)
                                .map(Issue::getDeadlineStatus)
                                .filter(deadlineStatus1 -> deadlineStatus1 == DeadlineStatus.FREEZE);
        Iterables.addAll(this.issues, issues);

        final int defaultFreezeLengthDays = StreamSupport.stream(issues.spliterator(), false)
                                                  .filter(i -> i.getFields() != null
                                                               && i.getFields().getProject() != null
                                                               && i.getFields().getProject().getFreezeLengthDays() != 0)
                                                  .mapToInt(i -> i.getFields().getProject().getFreezeLengthDays())
                                                         .max().orElse(0);
        final LocalDate freezeDate = deadline == null ? null : deadline.minus(defaultFreezeLengthDays, ChronoUnit.DAYS);

        deadlineStatus = DeadlineStatus.getDeadlineStatus(LocalDate.now(), freezeDate, deadline);
    }

    @Override
    public int compareTo(@Nonnull final WorkloadPeriod o)
    {
        return new CompareToBuilder()
            .append(getStart(), o.getStart())
            .append(getDeadline(), o.getDeadline(), new OptionalComparator())
            .append(getIssues().size(), o.getIssues().size())
            .append(hashCode(), o.hashCode())
            .toComparison();
    }

    @Override
    public boolean equals(final Object o)
    {
        if (this == o)
        {
            return true;
        }
        if (o == null || getClass() != o.getClass())
        {
            return false;
        }
        final WorkloadPeriod workload = (WorkloadPeriod) o;
        return Objects.equals(getStart(), workload.getStart()) &&
               Objects.equals(getDeadline(), workload.getDeadline()) &&
               Objects.equals(getIssues(), workload.getIssues());
    }

    public Optional<LocalDate> getDeadline()
    {
        return Optional.ofNullable(deadline);
    }

    public DeadlineStatus getDeadlineStatus()
    {
        return deadlineStatus;
    }

    public SortedSet<Issue> getIssues()
    {
        return issues;
    }
}

公共静态类WorkloadPeriod实现可比较
{
私有最终本地日期开始；
@可空
非公开最终本地日期截止日期；
私有最终分类集问题=新树集（）；
私有死线状态死线状态；
私人溪流解冻；
公共工作负载周期（最终LocalDate开始，最终Iterable问题）
{
this.start=start；
deadline=StreamSupport.stream（issues.spliterator（），false）
.map（问题：：获取截止日期）
.filter（可选：：isPresent）
.map（可选：：get）
.max（Ordering.natural（））
.orElse（空）；
inFreeze=StreamSupport.stream（issues.spliterator（），false）
.map（问题：：getDeadlineStatus）
.filter（deadlineStatus1->deadlineStatus1==DeadlineStatus.FREEZE）；
Iterables.addAll（this.issues，issues）；
final int defaultfreezelingthdays=StreamSupport.stream（issues.spliterator（），false）
.filter（i->i.getFields（）！=null
&&i.getFields（）.getProject（）！=null
&&i.getFields（）.getProject（）.GetFriezeLengthDays（）！=0）
.mapToInt（i->i.getFields（）.getProject（）.GetFriezeLengthDays（））
.max（）.orElse（0）；
最终本地日期冻结日期=截止日期==null？null:截止日期.减号（defaultFreezeLengthDays，ChronoUnit.DAYS）；
deadlineStatus=deadlineStatus.getDeadlineStatus（LocalDate.now（），冻结日期，截止日期）；
}
@凌驾
public int compareTo（@Nonnull final workload period o）
{
返回新的CompareToBuilder（）
.append（getStart（），o.getStart（））
.append（getDeadline（），o.getDeadline（），新选项Comparator（））
.append（getIssues（）.size（），o.getIssues（）.size（））
.append（hashCode（），o.hashCode（））
.toComparison（）；
}
@凌驾
公共布尔等于（最终对象o）
{
if（this==o）
{
返回true；
}
如果（o==null | | getClass（）！=o.getClass（））
{
返回false；
}
最终工作负载周期工作负载=（工作负载周期）o；
返回Objects.equals（getStart（），workload.getStart（））&&
Objects.equals（getDeadline（），workload.getDeadline（））&&
Objects.equals（getIssues（），workload.getIssues（））；
}
公共可选getDeadline（）
{
返回可选。不可用（截止日期）；
}
public DeadlineStatus getDeadlineStatus（）
{
返回死线状态；
}
公共分类数据集getIssues（）
{
退货问题；
}
}

你能重新组织你的问题以便更容易理解吗？问题类看起来怎么样？我只能给出一个高层次的答案，因为我不知道实际的问题

---

我建议使用Java8groupingBy子句来创建映射>。检查一下，如果您对这种方法有问题，只需使用EnumMap即可。

我不明白您希望更改代码的哪一部分。您提出了一个高级问题，但不清楚您希望对代码进行哪些更改。你能不能只张贴与问题相关的代码？即使这意味着发布示例代码而不是实际的代码，一些有形的期望输出差异也会得到赞赏。