32

我在工作中支持一个通用库，它对给定字符串执行许多检查以查看它是否是有效日期。Java API、commons-lang 库和 JodaTime 都有可以解析字符串并将其转换为日期的方法，让您知道它是否实际上是有效日期，但我希望有一种方法在不实际创建日期对象（或 JodaTime 库的情况下的 DateTime ）的情况下进行验证。例如，这里是一段简单的示例代码：

public boolean isValidDate(String dateString) {
    SimpleDateFormat df = new SimpleDateFormat("yyyyMMdd");
    try {
        df.parse(dateString);
        return true;
    } catch (ParseException e) {
        return false;
    }
}

这对我来说似乎很浪费，我们正在丢弃生成的对象。根据我的基准测试，我们在这个公共库中大约 5% 的时间用于验证日期。我希望我只是缺少一个明显的 API。任何建议都会很棒！

更新

假设我们始终可以始终使用相同的日期格式（可能是 yyyyMMdd）。我确实也考虑过使用正则表达式，但是它需要知道每个月的天数、闰年等等......

结果

解析日期 1000 万次

Using Java's SimpleDateFormat: ~32 seconds 
Using commons-lang DateUtils.parseDate: ~32 seconds
Using JodaTime's DateTimeFormatter: ~3.5 seconds 
Using the pure code/math solution by Slanec: ~0.8 seconds 
Using precomputed results by Slanec and dfb (minus filling cache): ~0.2 seconds

有一些非常有创意的答案，我很感激！我想现在我只需要决定我需要多少灵活性，我希望代码看起来像什么。我要说 dfb 的答案是正确的，因为它纯粹是我最初的问题中最快的。谢谢！

4

8 回答 8

16

如果您真的关心性能并且您的日期格式真的那么简单，只需预先计算所有有效字符串并将它们散列在内存中。你上面的格式只有大约 800 万个有效组合，直到 2050 年

由 Slanec 编辑- 参考实现

此实现取决于您的特定日期格式。它可以适应任何特定的日期格式（就像我的第一个答案一样，但更好一点）。

它制作了dates从 1900 到 2050 的所有日期（存储为字符串 - 其中有 54787 个），然后将给定的日期与存储的日期进行比较。

一旦dates创建了集合，它就快得要命了。一个快速的微基准测试显示，比我的第一个解决方案提高了 10 倍。

private static Set<String> dates = new HashSet<String>();
static {
    for (int year = 1900; year < 2050; year++) {
        for (int month = 1; month <= 12; month++) {
            for (int day = 1; day <= daysInMonth(year, month); day++) {
                StringBuilder date = new StringBuilder();
                date.append(String.format("%04d", year));
                date.append(String.format("%02d", month));
                date.append(String.format("%02d", day));
                dates.add(date.toString());
            }
        }
    }
}

public static boolean isValidDate2(String dateString) {
    return dates.contains(dateString);
}

PS 它可以修改为使用Set<Integer>甚至是Trove的TIntHashSet，这可以大大减少内存使用量（因此允许使用更大的时间跨度），然后性能下降到略低于我原来的解决方案的水平。

于 2012-07-14T02:44:15.170 回答
13

您可以恢复您的想法 - 当 String绝对没有日期时尝试尽快失败：

如果这些都不适用，那么尝试解析它 - 最好使用预制的静态Format对象，不要在每个方法运行时都创建一个。

评论后编辑

基于这个巧妙的技巧，我编写了一个快速验证方法。它看起来很丑，但比通常的库方法（应该在任何标准情况下使用！）快得多，因为它依赖于您的特定日期格式并且不创建Date对象。它将日期处理为 anint并继续。

daysInMonth()我稍微测试了这个方法（闰年条件取自 Peter Lawrey），所以我希望没有明显的错误。

快速（估计！）微基准表明加速了 30 倍。

public static boolean isValidDate(String dateString) {
    if (dateString == null || dateString.length() != "yyyyMMdd".length()) {
        return false;
    }

    int date;
    try {
        date = Integer.parseInt(dateString);
    } catch (NumberFormatException e) {
        return false;
    }

    int year = date / 10000;
    int month = (date % 10000) / 100;
    int day = date % 100;

    // leap years calculation not valid before 1581
    boolean yearOk = (year >= 1581) && (year <= 2500);
    boolean monthOk = (month >= 1) && (month <= 12);
    boolean dayOk = (day >= 1) && (day <= daysInMonth(year, month));

    return (yearOk && monthOk && dayOk);
}

private static int daysInMonth(int year, int month) {
    int daysInMonth;
    switch (month) {
        case 1: // fall through
        case 3: // fall through
        case 5: // fall through
        case 7: // fall through
        case 8: // fall through
        case 10: // fall through
        case 12:
            daysInMonth = 31;
            break;
        case 2:
            if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) {
                daysInMonth = 29;
            } else {
                daysInMonth = 28;
            }
            break;
        default:
            // returns 30 even for nonexistant months 
            daysInMonth = 30;
    }
    return daysInMonth;
}

PS您上面的示例方法将返回true“99999999”。我的只会在现有日期返回 true :)。

于 2012-07-14T02:44:36.040 回答
6

我认为了解某个日期是否有效的更好方法是定义如下方法：

public static boolean isValidDate(String input, String format) {
    boolean valid = false;

    try {
        SimpleDateFormat dateFormat = new SimpleDateFormat(format);
        String output = dateFormat.parse(input).format(format);
        valid = input.equals(output); 
    } catch (Exception ignore) {}

    return valid;
}

该方法一方面检查日期的格式是否正确，另一方面检查日期是否对应于有效日期。比如日期“2015/02/29”会被解析为“2015/03/01”，所以输入输出会不一样，方法会返回false。

于 2015-06-01T16:21:01.557 回答
2

这是我检查日期是否格式正确并且实际上是有效日期的方法。假设我们不需要 SimpleDateFormat 将不正确的日期转换为正确的日期，而是一个方法只返回 false。输出到控制台仅用于检查该方法在每个步骤中的工作方式。

public class DateFormat {

public static boolean validateDateFormat(String stringToValidate){
    String sdf = "yyyy-MM-dd HH:mm:ss";
    SimpleDateFormat format=new SimpleDateFormat(sdf);   
    String dateFormat = "[12]{1,1}[0-9]{3,3}-(([0]{0,1}[1-9]{1,1})|([1]{0,1}[0-2]{1,1}))-(([0-2]{0,1}[1-9]{1,1})|([3]{0,1}[01]{1,1}))[ ](([01]{0,1}[0-9]{1,1})|([2]{0,1}[0-3]{1,1}))((([:][0-5]{0,1}[0-9]{0,1})|([:][0-5]{0,1}[0-9]{0,1}))){0,2}";
    boolean isPassed = false;

    isPassed = (stringToValidate.matches(dateFormat)) ? true : false;


    if (isPassed){
        // digits are correct. Now, check that the date itself is correct
        // correct the date format to the full date format
        String correctDate = correctDateFormat(stringToValidate);
        try
        {
            Date d = format.parse(correctDate);
            isPassed = (correctDate.equals(new SimpleDateFormat(sdf).format(d))) ? true : false;
            System.out.println("In = " + correctDate + "; Out = " 
                    + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(d) + " equals = " 
                    + (correctDate.equals(new SimpleDateFormat(sdf).format(d))));
            // check that are date is less than current
            if (!isPassed || d.after(new Date())) {
                System.out.println(new SimpleDateFormat(sdf).format(d) + " is after current day " 
                        + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
                isPassed = false;
            } else {
                isPassed = true;
            }
        } catch (ParseException e) {
            System.out.println(correctDate + " Exception! " + e.getMessage());
            isPassed = false;
        }
    } else {
        return false;
    }
    return isPassed;
}

/**
 *  method to fill up the values that are not full, like 2 hours -> 02 hours
 *  to avoid undesirable difference when we will compare original date with parsed date with SimpleDateFormat
 */
private static String correctDateFormat(String stringToValidate) {
    String correctDate = "";
    StringTokenizer stringTokens = new StringTokenizer(stringToValidate, "-" + " " + ":", false);
    List<String> tokens = new ArrayList<>();
    System.out.println("Inside of recognizer");
    while (stringTokens.hasMoreTokens()) {
        String token = stringTokens.nextToken();
        tokens.add(token);
        // for debug
        System.out.print(token + "|");
    }
    for (int i=0; i<tokens.size(); i++){
        if (tokens.get(i).length() % 2 != 0){
            String element = tokens.get(i);
            element = "0" + element;
            tokens.set(i, element);
        }
    }
    // build a correct final string
    // 6 elements in the date: yyyy-MM-dd hh:mm:ss
    // come through and add mandatory 2 elements
    for (int i=0; i<2; i++){
        correctDate = correctDate + tokens.get(i) + "-";
    }
    // add mandatory 3rd (dd) and 4th elements (hh)
    correctDate = correctDate + tokens.get(2) + " " + tokens.get(3);
    if (tokens.size() == 4){
        correctDate = correctDate + ":00:00";
    } else if (tokens.size() == 5){
        correctDate = correctDate + ":" + tokens.get(4) + ":00";
    } else if (tokens.size() == 6){
        correctDate = correctDate + ":" + tokens.get(4) + ":" + tokens.get(5);
    }  

    System.out.println("The full correct date format is " + correctDate);
    return correctDate;
}

}

一个 JUnit 测试：

import static org.junit.Assert.*;
import junitparams.JUnitParamsRunner;
import junitparams.Parameters;
import org.junit.Test;
import org.junit.runner.RunWith;

@RunWith(JUnitParamsRunner.class)
public class DateFormatTest {

    @Parameters
    private static final Object[] getCorrectDate() {
        return new Object[] {
                new Object[]{"2014-12-13 12:12:12"},
                new Object[]{"2014-12-13 12:12:1"},
                new Object[]{"2014-12-13 12:12:01"},
                new Object[]{"2014-12-13 12:1"},
                new Object[]{"2014-12-13 12:01"},
                new Object[]{"2014-12-13 12"},
                new Object[]{"2014-12-13 1"},
                new Object[]{"2014-12-31 12:12:01"},
                new Object[]{"2014-12-30 23:59:59"},
        };
    }
    @Parameters
    private static final Object[] getWrongDate() {
        return new Object[] {
                new Object[]{"201-12-13 12:12:12"},
                new Object[]{"2014-12- 12:12:12"},
                new Object[]{"2014- 12:12:12"},
                new Object[]{"3014-12-12 12:12:12"},
                new Object[]{"2014-22-12 12:12:12"},
                new Object[]{"2014-12-42 12:12:12"},
                new Object[]{"2014-12-32 12:12:12"},
                new Object[]{"2014-13-31 12:12:12"},
                new Object[]{"2014-12-31 32:12:12"},
                new Object[]{"2014-12-31 24:12:12"},
                new Object[]{"2014-12-31 23:60:12"},
                new Object[]{"2014-12-31 23:59:60"},
                new Object[]{"2014-12-31 23:59:50."},
                new Object[]{"2014-12-31 "},
                new Object[]{"2014-12 23:59:50"},
                new Object[]{"2014 23:59:50"}
        };
    }

    @Test
    @Parameters(method="getCorrectDate")
    public void testMethodHasReturnTrueForCorrectDate(String dateToValidate) {
        assertTrue(DateFormat.validateDateFormatSimple(dateToValidate));
    }

    @Test
    @Parameters(method="getWrongDate")
    public void testMethodHasReturnFalseForWrongDate(String dateToValidate) {
        assertFalse(DateFormat.validateDateFormat(dateToValidate));
    }

}
于 2016-02-24T06:28:43.290 回答
1

如果以下行引发异常，则日期无效，否则将返回有效日期。请确保在以下语句中使用适当的 DateTimeFormatter。

LocalDate.parse(uncheckedStringDate, DateTimeFormatter.BASIC_ISO_DATE)

于 2017-12-27T13:51:29.940 回答
1 
 public static int checkIfDateIsExists(String d, String m, String y) {
        Integer[] array30 = new Integer[]{4, 6, 9, 11};
        Integer[] array31 = new Integer[]{1, 3, 5, 7, 8, 10, 12};

        int i = 0;
        int day = Integer.parseInt(d);
        int month = Integer.parseInt(m);
        int year = Integer.parseInt(y);

        if (month == 2) {
            if (isLeapYear(year)) {
                if (day > 29) {
                    i = 2; // false
                } else {
                    i = 1; // true
                }
            } else {
                if (day > 28) {
                    i = 2;// false
                } else {
                    i = 1;// true
                }
            }
        } else if (month == 4 || month == 6 || month == 9 || month == 11) {
            if (day > 30) {
                i = 2;// false
            } else {
                i = 1;// true
            }
        } else {
            i = 1;// true
        }

        return i;
    }

如果返回 i = 2 表示日期无效，如果日期有效则返回 1

于 2016-11-08T08:39:23.040 回答
0

可以结合使用正则表达式和手动闰年检查。因此：

if (matches ^\d\d\d\d((01|03|05|07|08|10|12)(30|31|[012]\d)|(04|06|09|11)(30|[012]\d)|02[012]\d)$)
    if (endsWith "0229")
         return true or false depending on the year being a leap year
    return true
return false
于 2013-06-18T19:07:40.807 回答
0

基于 dfb 的答案，您可以进行两步散列。

  1. 创建一个表示日期的简单对象（日、月、年）。计算接下来 50 年的每个日历日，这应该少于 20k 个不同的日期。
  2. 制作一个正则表达式，确认您的输入字符串是否与 yyyyMMdd 匹配，但不检查该值是否为有效日期（例如 99999999 将通过）
  3. 检查函数将首先执行一个正则表达式，如果成功 - 将其传递给哈希函数检查。假设您的日期对象是 8 位 + 8 位 + 8 位（1900 年后的年份），然后是 24 位 * 20k，那么整个哈希表应该非常小......当然低于 500 KB，如果序列化和压缩。
于 2012-07-14T04:31:44.870 回答