检查月份，日期或年份是否在字符串格式的两个日期范围内

时间：2020-01-23 17:44:14

标签： java date datetime java-time

I originally asked this question here with a different use case，但现在我意识到我可以为这个问题提供更多案例。

我有一个字符串过滤器，只能接受3种日期格式-YYYY，YYYY-MM，YYYY-MM-DD。

我想检查请求的字符串是否在两个字符串值日期的范围内。

比方说，我有两个日期字符串，可以是上述3种日期格式中的任何一种

用例1

开始日期：2010-05-15和结束日期：2020-05。

以下所有requested String 都在范围内结果：

2010，2020，2010-05，2020-05，2020-05-22，2010-05-15，2010-05-22，2015-02-25

下面的所有requested String都在范围内不是

2009，2021，2010-04，2020-06，2010-05-14，2020-06-01

用例2

开始日期：2010和结束日期：2020-05-15

以下所有值属于范围结果：

2010，2020，2010-05，2020-05，2010-05-22，2010-01-01，2020-05-15，2015-02-25

以下所有值均不在范围内

2009，2021，2020-06，2020-05-16，2020-06-01

用例3

开始日期：NULL和结束日期：2020-05

2020-05-31之前的所有请求日期都在范围内结果中：

2020-05-31之后的所有值均不在范围内。

用例4

开始日期：2010-05-15和结束日期：NULL

在2010-05-15 之后的所有请求日期都在范围内结果中：

在2010-05-15 之前的所有值均不在范围内。

我正在使用Java时间检查日期是否在给定日期之前或之后，但是在我的情况下，我有一个字符串作为请求日期，开始日期和结束日期，可以是3个日期中的任何一个格式。

我不确定这是否是有效的解决方案，但这就是我的想法

将所有日期（请求的，开始和结束）简单地分解为数字，然后将请求的年份与开始和结束的年份进行比较（如果请求日期中的月份可用并且在开始和结束中也可用），然后比较月份是否为范围内，并且日期相同。

有人可以帮助解决这个问题吗？

6 个答案:

答案 0 :(得分：3)

将所有字符串输入转换为LocalDate个对象

停止在字符串中思考。这些字符串仅用于用户界面和将值序列化到存储。当您的应用程序运行时，您应该使用对象 java.time 对象，最终LocalDate来执行逻辑。

将所有输入转换为LocalDate。

检查输入的长度。

if( input.length() = 4 ) {…}

如果输入的字符长度为4个，则解析为Year。如果错误的输入通过了过滤器，则抛出异常陷阱。从一年中起，通过致电atDay获得LocalDate。

try{
    Year year = Year.parse( "2020" ) ; 
     LocalDate ld = year.atDay( 1 ) ;
} catch ( DateTimeParseException e ) {
    …
}

如果输入为七个字符，则解析为YearMonth。通过LocalDate方法获得atDay的表单。

try{
    YearMonth YearMonth = YearMonth.parse( "2020-05" ) ; 
     LocalDate ld = yearMonth.atDay( 1 ) ;
} catch ( DateTimeParseException e ) {
    …
}

如果输入的字符为10个字符，则解析为LocalDate。

try{
    LocalDate localDate = LocalDate.parse( "2020-05-23" ) ; 
} catch ( DateTimeParseException e ) {
    …
}

一旦所有LocalDate对象都放置到位，请进行比较。定义时间跨度时，请始终使用“半开式”方法。开头是包含，而结尾是包含。

提示：“不早于”是询问“等于或晚于”的较短方法。

( ! target.isBefore( start ) ) && target.isBefore( stop )

答案 1 :(得分：3)

由于您的日期采用yyyy-MM-dd格式，因此您应该能够执行字符串比较，并确保只比较相同长度的字符串（注意有关比较不同长度日期的规则） ：

private static boolean isDateInRange(String startDate, String endDate, String date) {
    return (null == startDate || compareDateString(startDate, date) <= 0)
            && (null == endDate || compareDateString(date, endDate) <= 0);
}

private static int compareDateString(String date1, String date2) {
    if (date1.length() == date2.length())
        return date1.compareTo(date2);

    int length = Math.min(date1.length(), date2.length());
    return date1.substring(0, length).compareTo(date2.substring(0, length));
}

您可以通过以下方式进行检查：

String startDate = "2010-05-15";
String endDate = "2020-05";
String date = "2020-06";

boolean inRange = isDateInRange(startDate, endDate, date);

答案 2 :(得分：2)

Answer by Basil Bourque简洁明了，因此您应该使用它，但是它只能工作，因为日期格式是简单的ISO-8601文本。如果格式不同，则需要先解析它们，然后才能进行比较。这是一个解析字符串的解决方案，这当然会使逻辑更加复杂。

我将从创建一个帮助器类开始：

/**
 * Class for storing a {@code Temporal} of varying precision,
 * {@code Year}, {@code YearMonth}, or {@code LocalDate}.
 */
class DynamicTemporal {

    private enum Precision {
        YEAR {
            @Override
            protected int compare(Temporal a, Temporal b) {
                return widen(a).compareTo(widen(b));
            }
            private Year widen(Temporal value) {
                return Year.from(value);
            }
        },
        MONTH {
            @Override
            protected int compare(Temporal a, Temporal b) {
                return widen(a).compareTo(widen(b));
            }
            private YearMonth widen(Temporal value) {
                return YearMonth.from(value);
            }
        },
        DAY {
            @Override
            protected int compare(Temporal a, Temporal b) {
                return widen(a).compareTo(widen(b));
            }
            private LocalDate widen(Temporal value) {
                return (LocalDate) value;
            }
        };
        protected abstract int compare(Temporal a, Temporal b);
    }

    private final Temporal value;
    private final Precision precision;

    public static DynamicTemporal parse(String text) {
        if (text == null || text.equals("NULL"))
            return null;
        if (text.length() >= 10)
            return new DynamicTemporal(LocalDate.parse(text), Precision.DAY);
        if (text.length() >= 7)
            return new DynamicTemporal(YearMonth.parse(text), Precision.MONTH);
        return new DynamicTemporal(Year.parse(text), Precision.YEAR);
    }

    private DynamicTemporal(Temporal value, Precision precision) {
        this.value = value;
        this.precision = precision;
    }

    public int compareTo(DynamicTemporal other) {
        Precision effectivePrecision = (this.precision.compareTo(other.precision) <= 0 ? this.precision : other.precision);
        return effectivePrecision.compare(this.value, other.value);
    }
}

现在，您可以轻松实现isDateInRange()方法：

private static boolean isDateInRange(String start, String end, String date) {
    DynamicTemporal dateTemporal = DynamicTemporal.parse(date);
    DynamicTemporal startTemporal = DynamicTemporal.parse(start);
    DynamicTemporal endTemporal = DynamicTemporal.parse(end);
    if (startTemporal != null && dateTemporal.compareTo(startTemporal) < 0)
        return false; // date is before start
    if (endTemporal != null && dateTemporal.compareTo(endTemporal) > 0)
        return false; // date is after end
    return true;
}

测试（从问题开始） 

public static void main(String[] args) {
    test("2010-05-15", "2020-05", true, "2010", "2020", "2010-05", "2020-05", "2020-05-22", "2010-05-15", "2010-05-22", "2015-02-25");
    test("2010-05-15", "2020-05", false, "2009", "2021", "2010-04", "2020-06", "2010-05-14", "2020-06-01");

    test("2010", "2020-05-15", true, "2010", "2020", "2010-05", "2020-05", "2010-05-22", "2010-01-01", "2020-05-15", "2015-02-25");
    test("2010", "2020-05-15", false, "2009", "2021", "2020-06", "2020-05-16", "2020-06-01");

    test("NULL", "2020-05", true, "2020-05-31", "2020-05", "2020", "2020-05-30", "2020-04", "2019");
    test("NULL", "2020-05", false, "2020-06-01", "2020-06", "2021", "2020-06-02", "2020-07", "2022");

    test("2010-05-15", "NULL", true, "2010-05-15", "2010-05", "2010", "2010-05-16", "2010-06", "2011");
    test("2010-05-15", "NULL", false, "2010-05-14", "2010-04", "2009", "2010-05-13", "2010-03", "2008");
}
private static void test(String start, String end, boolean expected, String... dates) {
    for (String date : dates) {
        boolean actual = isDateInRange(start, end, date);
        System.out.printf("isDateInRange(%-10s, %-10s, %-10s) = %-5s   %s%n",
                          start, end, date, actual, (actual == expected ? "OK" : "FAILED!"));
    }
}

输出 

isDateInRange(2010-05-15, 2020-05   , 2010      ) = true    OK
isDateInRange(2010-05-15, 2020-05   , 2020      ) = true    OK
isDateInRange(2010-05-15, 2020-05   , 2010-05   ) = true    OK
isDateInRange(2010-05-15, 2020-05   , 2020-05   ) = true    OK
isDateInRange(2010-05-15, 2020-05   , 2020-05-22) = true    OK
isDateInRange(2010-05-15, 2020-05   , 2010-05-15) = true    OK
isDateInRange(2010-05-15, 2020-05   , 2010-05-22) = true    OK
isDateInRange(2010-05-15, 2020-05   , 2015-02-25) = true    OK
isDateInRange(2010-05-15, 2020-05   , 2009      ) = false   OK
isDateInRange(2010-05-15, 2020-05   , 2021      ) = false   OK
isDateInRange(2010-05-15, 2020-05   , 2010-04   ) = false   OK
isDateInRange(2010-05-15, 2020-05   , 2020-06   ) = false   OK
isDateInRange(2010-05-15, 2020-05   , 2010-05-14) = false   OK
isDateInRange(2010-05-15, 2020-05   , 2020-06-01) = false   OK
isDateInRange(2010      , 2020-05-15, 2010      ) = true    OK
isDateInRange(2010      , 2020-05-15, 2020      ) = true    OK
isDateInRange(2010      , 2020-05-15, 2010-05   ) = true    OK
isDateInRange(2010      , 2020-05-15, 2020-05   ) = true    OK
isDateInRange(2010      , 2020-05-15, 2010-05-22) = true    OK
isDateInRange(2010      , 2020-05-15, 2010-01-01) = true    OK
isDateInRange(2010      , 2020-05-15, 2020-05-15) = true    OK
isDateInRange(2010      , 2020-05-15, 2015-02-25) = true    OK
isDateInRange(2010      , 2020-05-15, 2009      ) = false   OK
isDateInRange(2010      , 2020-05-15, 2021      ) = false   OK
isDateInRange(2010      , 2020-05-15, 2020-06   ) = false   OK
isDateInRange(2010      , 2020-05-15, 2020-05-16) = false   OK
isDateInRange(2010      , 2020-05-15, 2020-06-01) = false   OK
isDateInRange(NULL      , 2020-05   , 2020-05-31) = true    OK
isDateInRange(NULL      , 2020-05   , 2020-05   ) = true    OK
isDateInRange(NULL      , 2020-05   , 2020      ) = true    OK
isDateInRange(NULL      , 2020-05   , 2020-05-30) = true    OK
isDateInRange(NULL      , 2020-05   , 2020-04   ) = true    OK
isDateInRange(NULL      , 2020-05   , 2019      ) = true    OK
isDateInRange(NULL      , 2020-05   , 2020-06-01) = false   OK
isDateInRange(NULL      , 2020-05   , 2020-06   ) = false   OK
isDateInRange(NULL      , 2020-05   , 2021      ) = false   OK
isDateInRange(NULL      , 2020-05   , 2020-06-02) = false   OK
isDateInRange(NULL      , 2020-05   , 2020-07   ) = false   OK
isDateInRange(NULL      , 2020-05   , 2022      ) = false   OK
isDateInRange(2010-05-15, NULL      , 2010-05-15) = true    OK
isDateInRange(2010-05-15, NULL      , 2010-05   ) = true    OK
isDateInRange(2010-05-15, NULL      , 2010      ) = true    OK
isDateInRange(2010-05-15, NULL      , 2010-05-16) = true    OK
isDateInRange(2010-05-15, NULL      , 2010-06   ) = true    OK
isDateInRange(2010-05-15, NULL      , 2011      ) = true    OK
isDateInRange(2010-05-15, NULL      , 2010-05-14) = false   OK
isDateInRange(2010-05-15, NULL      , 2010-04   ) = false   OK
isDateInRange(2010-05-15, NULL      , 2009      ) = false   OK
isDateInRange(2010-05-15, NULL      , 2010-05-13) = false   OK
isDateInRange(2010-05-15, NULL      , 2010-03   ) = false   OK
isDateInRange(2010-05-15, NULL      , 2008      ) = false   OK

答案 3 :(得分：1)

将所有内容转换为日期范围。将日期范围表示为从开始日期（含首尾）到结束日期不包括的半开放时间间隔。并将两个日期分别表示为两个LocalDate对象。

例如，在您的用例1中

开始日期：2010-05-15和结束日期：2020-05

从2010年5月15日起，到2020年6月1日，

日期将变为。

要测试2010是否在此范围内，请将2010转换为从2010-01-01到2011-01-01排他的范围。现在且仅当两个范围重叠时，2010才在该范围内。如果且仅当第一个起始日期在第二个日期之前，并且第二个起始日期在第一个日期之前，它们会这样做。使用LocalDate.isBefore()。我们需要“严格地在……之前”，而这种方法正是为我们提供了这一点。由于2010-05-15在2011-01-01 之前，而 2010-01-01在2020-06-01之前，因此范围重叠，因此我们得出2010年在范围内的结论。

案例1的另一个示例，要测试2010-05-14是否在相同范围内，请将其转换为从2010-05-14到2010-05-15（不包括）的范围 。查看2010-05-15是否在2010-05-15 之前和 2010-05-14在2020-06-01之前。上半部分已经是错误的，因此我们得出的结论是日期不在范围内。

实施说明：我可能会使用此格式化程序来解析您的所有字符串：

    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("uuuu[-MM[-dd]]");

您可以使用此格式化程序的parseBest方法从您提到的任何字符串中获取LocalDate，YearMonth或Year。在每种情况下，您都可以从那里转换。

链接： Determine Whether Two Date Ranges Overlap

答案 4 :(得分：1)

我不确定这是否是有效的解决方案，但这就是我的意思 思考

只需将所有日期（要求，开始和结束）分解为数字，然后 比较请求的年份与开始和结束的年份（如果在月份中） 要求的日期可用，也可以在开始和结束日期使用 然后比较月份是否在范围内，日期是否相同。

是的，您的方法是有效的。 java.time的类没有提供对它的完美支持，但是使用低级的TemporalAccessor接口，可以通过以下方式实现：

class IsInRangeWithMissingFields {

    @Test
    void useCase1() {
        assertTrue(isInRange("2010-05-15", "2020-05", "2010"));
        assertTrue(isInRange("2010-05-15", "2020-05", "2020"));
        assertTrue(isInRange("2010-05-15", "2020-05", "2010-05"));
        assertTrue(isInRange("2010-05-15", "2020-05", "2020-05"));
        assertTrue(isInRange("2010-05-15", "2020-05", "2020-05-22"));
        assertTrue(isInRange("2010-05-15", "2020-05", "2010-05-15"));
        assertTrue(isInRange("2010-05-15", "2020-05", "2010-05-22"));
        assertTrue(isInRange("2010-05-15", "2020-05", "2015-02-25"));
        assertFalse(isInRange("2010-05-15", "2020-05", "2009"));
        assertFalse(isInRange("2010-05-15", "2020-05", "2021"));
        assertFalse(isInRange("2010-05-15", "2020-05", "2010-04"));
        assertFalse(isInRange("2010-05-15", "2020-05", "2020-06"));
        assertFalse(isInRange("2010-05-15", "2020-05", "2010-05-14"));
        assertFalse(isInRange("2010-05-15", "2020-05", "2020-06-01"));
    }

    @Test
    void useCase2() {
        assertTrue(isInRange("2010", "2020-05-15", "2010"));
        assertTrue(isInRange("2010", "2020-05-15", "2020"));
        assertTrue(isInRange("2010", "2020-05-15", "2010-05"));
        assertTrue(isInRange("2010", "2020-05-15", "2020-05"));
        assertTrue(isInRange("2010", "2020-05-15", "2010-05-22"));
        assertTrue(isInRange("2010", "2020-05-15", "2010-01-01"));
        assertTrue(isInRange("2010", "2020-05-15", "2020-05-15"));
        assertTrue(isInRange("2010", "2020-05-15", "2015-02-25"));
        assertFalse(isInRange("2010", "2020-05-15", "2009"));
        assertFalse(isInRange("2010", "2020-05-15", "2021"));
        assertFalse(isInRange("2010", "2020-05-15", "2020-06"));
        assertFalse(isInRange("2010", "2020-05-15", "2020-05-16"));
        assertFalse(isInRange("2010", "2020-05-15", "2020-06-01"));
    }

    @Test
    void useCase3() {
        assertTrue(isInRange(null, "2020-05", "2020-05-31"));
        assertFalse(isInRange(null, "2020-05", "2020-06-01"));
    }

    @Test
    void useCase4() {
        assertTrue(isInRange("2010-05-15", null, "2010-05-15"));
        assertFalse(isInRange("2010-05-15", null, "2010-05-14"));
    }

    private static DateTimeFormatter formatter = DateTimeFormatter.ofPattern("uuuu[-MM[-dd]]");

    public static boolean isInRange(String startStr, String endStr, String requestStr) {
        TemporalAccessor request = formatter.parse(requestStr);

        // is request before start?
        if (startStr != null) {
            TemporalAccessor start = formatter.parse(startStr);
            if (request.get(ChronoField.YEAR)
                    < start.get(ChronoField.YEAR)) {
                return false;
            }
            if (request.get(ChronoField.YEAR)
                    == start.get(ChronoField.YEAR)) {
                if (request.isSupported(ChronoField.MONTH_OF_YEAR)
                        && start.isSupported(ChronoField.MONTH_OF_YEAR)) {
                    if (request.get(ChronoField.MONTH_OF_YEAR)
                            < start.get(ChronoField.MONTH_OF_YEAR)) {
                        return false;
                    }
                    if (request.get(ChronoField.MONTH_OF_YEAR)
                            == start.get(ChronoField.MONTH_OF_YEAR)) {
                        if (request.isSupported(ChronoField.DAY_OF_MONTH)
                                && start.isSupported(ChronoField.DAY_OF_MONTH)) {
                            if (request.get(ChronoField.DAY_OF_MONTH)
                                    < start.get(ChronoField.DAY_OF_MONTH)) {
                                return false;
                            }
                        }
                    }
                }
            }
        }

        // is request after end?
        if (endStr != null) {
            TemporalAccessor end = formatter.parse(endStr);
            if (request.get(ChronoField.YEAR) > end.get(ChronoField.YEAR)) {
                return false;
            }
            if (request.get(ChronoField.YEAR) == end.get(ChronoField.YEAR)) {
                if (request.isSupported(ChronoField.MONTH_OF_YEAR)
                        && end.isSupported(ChronoField.MONTH_OF_YEAR)) {
                    if (request.get(ChronoField.MONTH_OF_YEAR)
                            > end.get(ChronoField.MONTH_OF_YEAR)) {
                        return false;
                    }
                    if (request.get(ChronoField.MONTH_OF_YEAR)
                            == end.get(ChronoField.MONTH_OF_YEAR)) {
                        if (request.isSupported(ChronoField.DAY_OF_MONTH)
                                && end.isSupported(ChronoField.DAY_OF_MONTH)) {
                            if (request.get(ChronoField.DAY_OF_MONTH)
                                    > end.get(ChronoField.DAY_OF_MONTH)) {
                                return false;
                            }
                        }
                    }
                }
            }
        }

        return true;
    }

}

此单元测试在我的计算机上以绿色显示。

答案 5 :(得分：-1)

:User
相关问题
最新问题