How to check if date is between interval in java?

Question

I have six int variables: currentMonth, currentDay, monthFrom, dayFrom, monthUntil and dayUntil. I need to check if todays month and day falls within a range of from and until variables.

For example if currentMonth = 1, currentDay = 2, monthFrom = 11, dayFrom = 24, monthUntil = 3 and dayUntil = 3 the date is in the interval and the method should return true.

I'm not sure how to do it though. Is there any other option than to check every possible outcome using ifs?

Answer 1

Just do a quick range check with the calendar:

Note: Make sure to import java.util.GregorianCalendar;

public static boolean isDateInRange(int month, int day,
                                    int monthFrom, int dayFrom,
                                    int monthUntil, int dayUntil) {
    int yearRoll = 0;
    int currentRoll = 0;
    if (monthUntil < monthFrom) yearRoll = -1; // Ensures date is calculated correctly.
    if (month >= monthFrom && yearRoll < 0) currentRoll = -1;

    GregorianCalendar testDate = new GregorianCalendar(currentRoll, month, day);
    GregorianCalendar startDate = new GregorianCalendar(yearRoll, monthFrom, dayFrom);
    GregorianCalendar endDate = new GregorianCalendar(0, monthUntil, dayUntil);

    // This makes it pass if its between OR EQUAL to the interval.
    // Remove if you only want to pass dates explicitly BETWEEN intervals.
    if (testDate.compareTo(startDate) == 0 || testDate.compareTo(endDate) == 0) {
        return true;
    }

    return !(testDate.before(startDate) || testDate.after(endDate));
}

This will also take into account the fact that say February is between November and March. Since November is a part of the previous year, it will move the from date back a year to ensure passing.

What it doesn't take into account however, is the fact that February has an extra day on leap-years. To add extra-precision, you need integers for the years. You can do the following:

public static boolean isDateInRange(int year, int month, int day,
                                    int yearFrom, int monthFrom, int dayFrom,
                                    int yearUntil, int monthUntil, int dayUntil) {

    GregorianCalendar testDate = new GregorianCalendar(year, month, day);
    GregorianCalendar startDate = new GregorianCalendar(yearFrom, monthFrom, dayFrom);
    GregorianCalendar endDate = new GregorianCalendar(yearUntil, monthUntil, dayUntil);

    return !(testDate.before(startDate) || testDate.after(endDate));
}

And here is an implementation with the date values you gave plus a few more:

public static void main(String[] args) {
    System.out.println(isDateInRange(1, 2,
                                     11, 24,
                                     3, 3));
    System.out.println(isDateInRange(11, 25,
                                     11, 24,
                                     3, 3));
    System.out.println(isDateInRange(1, 2,
                                     1, 1,
                                     3, 3));
    System.out.println(isDateInRange(1, 22,
                                     1, 21,
                                     1, 25));
}

And the results are:

true
true
true
true

Will also work with @Marvin's tests.

Answer 2

I would suggest using java.time.MonthDay to represent each value involved. You then need to consider two alternative situations:

• from is before or equal to until, in which case you need to perform a test of from <= current && current <= until.
• from is later than until, in which case you need to perform a test of current <= until || current >= from

So:

public static boolean isBetween(
    int currentMonth, int currentDay,
    int fromMonth, int fromDay,
    int untilMonth, int untilDay)
{
    MonthDay current = MonthDay.of(currentMonth, currentDay);
    MonthDay from = MonthDay.of(fromMonth, fromDay);
    MonthDay until = MonthDay.of(untilMonth, untilDay);

    if (from.compareTo(until) <= 0)
    {
        return from.compareTo(current) <= 0 &&
            current.compareTo(until) <= 0;
    }
    else
    {
        return current.compareTo(until) <= 0 ||
            current.compareTo(from) >= 0;
    }
}

The two return statements could be combined, but it's probably simpler not to.

(This gives the same results as Marvin's code for his test cases.)

Answer 3

You can create LocalDate objects from your inputs and let java do the checks. The only difficulty is to determine which years all those dates should fall in.

import java.time.LocalDate;

public class DateBetween {

    public static void main(String[] args) {
        System.out.println(isBetween(1, 2, 11, 24, 3, 3)); // true
        System.out.println(isBetween(4, 4, 1, 20, 6, 3)); // true
        System.out.println(isBetween(1, 1, 2, 3, 7, 8)); // false
        System.out.println(isBetween(11, 4, 2, 3, 7, 8)); // false
        System.out.println(isBetween(2, 29, 2, 3, 7, 8)); // true
        System.out.println(isBetween(2, 29, 11, 24, 3, 3)); // true
        System.out.println(isBetween(1, 1, 1, 1, 1, 1)); // true
    }

    private static boolean isBetween(int currentMonth, int currentDay, int monthFrom, int dayFrom, int monthUntil,
            int dayUntil) {
        // Default to 2000 so that Feb 29st will be valid.
        int currentYear = 2000;
        LocalDate dateFrom = LocalDate.of(currentYear, monthFrom, dayFrom);
        LocalDate dateUntil = LocalDate.of(currentYear, monthUntil, dayUntil);
        if (dateFrom.isAfter(dateUntil)) {
            // Assume dateUntil is in the next year (e.g. for 11/24/2000 -
            // 6/3/2001)
            dateUntil = dateUntil.plusYears(1);
        }
        // Day to check in current year (for non-overlapping ranges)
        LocalDate currentDateThisYear = LocalDate.of(currentYear, currentMonth, currentDay);
        // Day to check in next year (for overlapping ranges)
        LocalDate currentDateNextYear = currentDateThisYear.plusYears(1);
        if (!(currentDateThisYear.isBefore(dateFrom) || currentDateThisYear.isAfter(dateUntil))) {
            return true;
        } else if (!(currentDateNextYear.isBefore(dateFrom) || currentDateNextYear.isAfter(dateUntil))) {
            return true;
        }
        // Neither of the days to check are in the range
        return false;
    }
}

The method considers dateUntil to be in the next year if it is after dateFrom. For overlapping ranges the "current" date is checked for the current as well as for the next year, as e.g. in the range from "Nov 1st" (2017) to "Mar 1st" (2018) you might want to check for "Dec 24st" or "Jan 1st".

Obviously this will become a lot easier if you can also provide currentYear, yearFrom and yearUntil.

Answer 4

Here’s the hack.

I didn’t want to use neither GregorianCalendar nor LocalDate when you don’t have years for your dates because they force you to pick a year anyway. Particularly with February 29 this is not just picking any year you can think of.

First I want you to think about, is there a way you can solve the year problem where you get your dates from, and also, why are you having your dates as two ints when there are date and calendar classes to choose from? If it doesn’t make sense to add a year component to your dates, I would still think you could benefit from always storing them as MonthDay rather than two ints. On Android you will have to weigh the cost of the dependency on ThreeTenABP, of course, but it seems to me to be a future-proof one in this case: let’s hope there will come Java 8 for Android with java.time built in sooner or later.

In the meantime, if you don’t want to use MonthDay, here’s the solution without any library classes at all. Just pretend there are 32 days in a month and calculate a day number for each of the dates involved. It won’t make sense as a day number, but it will have the convenient property that we want: the day numbers will be in the same order as the days in the calendar.

public static boolean isBetween(int currentMonth, int currentDay, 
        int monthFrom, int dayFrom, 
        int monthUntil, int dayUntil) {
    final int daysInMonth = 32; // just imagine; pick any number >= 31
    int current = currentMonth * daysInMonth + currentDay;
    int from = monthFrom * daysInMonth + dayFrom;
    int until = monthUntil * daysInMonth + dayUntil;

    if (until < from) { // until is in the following year
        return current >= from || current <= until;
    } else {
        return current >= from && current <= until;
    }
}

Please adjust the use of < and <= etc. to your exact requirements.

One of the downsides (apart for the trickyness or obscurity) is you get no input validation at all. I may nonsensically call isBetween(55, -45, 83, 98, -29, 84) and it will return either false or true with no sign that anything is not quite right.

Link: Get java.time classes for Android in ThreeTenABP.