Question

我创建了一个截止日期跟踪器，用于管理某人在一段时间内完成的工作量。

截止日期跟踪器将问题分为“工作负载期”，这些是具有相同截止日期的问题集合。句点的状态是类型枚举，可以是UNSCHEDULED，FUTURE，FREEZE或OVERDUE。

但是，如果只有部分问题被冻结，我遇到的问题是WorkloadPeriods被定义为“冻结”。每个问题都有一个freezeLength，deadlineDate和deadlineStatus。

我想将这些“冻结”问题分成单独的WorkloadPeriod。如何通过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;
    }
}

Answer 1

您可以重新构建问题，以便更容易理解吗？问题类怎么样？因为我不知道实际问题，所以我只能在这里给出高级答案。

我建议使用Java 8 groupingBy 子句来创建Map＆lt; Issue.Type，Set＆lt;类型＆GT;取代。检查一下，如果您遇到这种方法的问题，请改用EnumMap。

按枚举类型

1 个答案: