Java Date and Time (JSR 310): does a temporal range contain value without iterating all of them

Question

I have a custom range (~ Collection) which has 2 Temporal bounds (from and to) and can enumerate all values between those 2 bounds in time by incrementing with a given TemporalUnit incrementUnitType.

private final Temporal_ from;
private final Temporal_ to;
private final TemporalUnit incrementUnitType; // For example Month, Day,  Minute, ...

In it, I need to implement a contains method, to check if iterating through that range would contain a specific value. For example if it contains 8 March. Here's how I 'd like to write that method:

public boolean contains(Temporal_ value) {
    ...
    if (from.until(value, incrementUnitType) < 0
            || value.until(to, incrementUnitType) <= 0) {
        return false; // Out of bounds
    }
    // This doesn't work because 1-MAR + 1 month doesn't include 8-MAR
    return true;
}

Here's a few iterations:

• from - to (incrementUnitType)
• 1-MAR - 10-APR (1 day): 1-MAR, 2-MAR, 3-MAR, 4-MAR, ..., 8-APR, 9-APR
• 1-MAR - 10-APR (1 week): 1-MAR, 8-MAR, 15-MAR, 22-MAR, 29-MAR, 5-APR
• 1-MAR - 10-APR (1 month): 1-MAR, 1-APR

The code above would incorrect return true for 8-MAR in the last case. Here's how I need to write that code to work, by doing a for loop and check every possible value:

public boolean contains(Temporal_ value) {
    ...
    if (from.until(value, incrementUnitType) < 0
            || value.until(to, incrementUnitType) <= 0) {
        return false; // Out of bounds
    }
    // This works but it kills scalability
    for (long i = 0; i < getSize(); i++) {
        Temporal_ temporal = get(i);
        if (value.equals(temporal)) {
            return true;
        }
    }
    return false;
}

That's a scalability issue. Is there any way I can avoid that?

Answer 1

You can use the method Temporal.until to get your result. As it returns "the number of complete units between the two temporals" (doc), you can add this number to from and see if it equals the value, but that does not work right away.

long wholeAmount = from.until(value, incrementUnitType)
return value.equals(from.plus(wholeAmount, incrementUnitType));

As you noticed, the problem is that some temporal units are not always the same duration (a month may be 28, 29, 30 or 31 day long for instance). until and plus may not be consistent ( i.e. temporal.until(temporal.plus(1,ChronoUnit.MONTHS),ChronoUnit.MONTHS) may be 0 while we added one month) .

Quoting the doc :

In some cases, changing a field is not fully defined. For example, if the target object is a date representing the 31st January, then adding one month would be unclear. In cases like this, the field is responsible for resolving the result. Typically it will choose the previous valid date, which would be the last valid day of February in this example.

This means the we should also check for wholeAmount + 1, just in case the whole amount was rounded.

// ... out of bound check
// ...
long wholeAmount = from.until(value, incrementUnitType)
return value.equals(from.plus(wholeAmount, incrementUnitType)) || value.equals(from.plus(wholeAmount + 1, incrementUnitType));

Dealing with Temporal seems tricky so I cannot be sure that it will work with every unit and every temporal (be sure to check that incrementUnitType is compatible with your temporal). There are probably several edge cases which should be tested.

Answer 2

The most efficient solution would be separate logic for each increment unit.

• With DAYS you can just check if the date is between the start and end.
• With WEEKS you can call toEpochDays() on both, subtract them and check if it divides by 7
• With MONTHS you can check if the day-of-month is the same

I would caution against using Temporal as the input type if you can avoid it, as it makes processing harder. One option if you must use it it to call LocalDate.from(temporal) on the input to allow the logic to work internally on LocalDate.