SimpleDateFormat parses illegal date string

[Sebastian Janisch]

Hey guys,

I am having a SimpleDateFormat instance and passing an illegal date string to it's parse method, expecting an exception.

For some reason however, the pasing goes thru. The Date object is stale though.

Here is the code

SimpleDateFormat format = new SimpleDateFormat("dd.MM.yyyy");

try
{
    Date date = format.parse("2010.09.17");
}
catch(ParseException e)
{
    e.printStackTrace();
}

Thanks

edit: is there any other way to check whether or not a date string conforms to a given format except for working with exceptions?

[Christophe Verré]

I'm not even thinking why it goes through but if you use format.setLenient(false);, you should get a ParseException.

[Rob Spoor]

Call setLenient(false). By default, most DateFormat implementations are lenient. That means that they allow things like February 30th, or even a thirteenth month. It will just wrap these around - February 30th is March 2nd (or 1st in leap years), the thirteenth month will be January of the next year.
In your case it will use 2010 as the number of days in September 2017 (or 17, don't really know). It will overflow quite a few years I reckon

By turning leniency off you are prohibiting this behaviour. February 30th, a thirteenth month, or September 2010th 2017 will all cause errors.

[Sebastian Janisch]

Awesome, it worked.

Any idea as to how to check for the validity of a date string other than working with exceptions like this:

 public static boolean isValid(String dateString)
    {
        for (SimpleDateFormat format : DEFAULT_DATE_FORMATS)
        {
            try
            {
                format.parse(dateString);

                return true;
            }
            catch (ParseException e)
            {
            }
        }

        return false;
    }   

[Christophe Verré]

I think that dealing with the exception is the easiest way. The API already parses the string for you, why would you do it on your side too ?

[Sebastian Janisch]

Christophe Verré wrote:I think that dealing with the exception is the easiest way. The API already parses the string for you, why would you do it on your side too ?

I was looking for a method like 'isValidFormat' so I don't have to go thru the exceptions dealing.

[Christophe Verré]

There's one :

public static boolean isValidFormat(DateFormat format, String date) {
 	try {
		format.parse(date);  
	}  
	catch (ParseException e) {  
		return false;
	}
	return true;
}

but not in DateFormat

[Rob Spoor]

Ah, more people to tell about the other parse method!

public static boolean isValidFormat(DateFormat format, String date)
{
    ParsePosition position = new ParsePosition(0);
    Date date = format.parse(date, position); // no exception
    return date != null;
    //return date != null && position.getIndex() == date.length();
}

DateFormat.parse(String) uses DateFormat.parse(String, ParsePosition) internally, and throws an exception if parsing fails:

        ParsePosition pos = new ParsePosition(0);
        Date result = parse(source, pos);
        if (pos.index == 0)
            throw new ParseException("Unparseable date: \"" + source + "\"" ,
                pos.errorIndex);
        return result;

As for the two returns from my code. The first return statement is the basic form; it will only check if the date String starts with a valid date. If the pattern is yyyy-MM-dd then it will consider 2010-09-17abc as valid. The second form also checks if the parsing consumes all of the String. With the given example, date.length() is 13 whereas parsing stops at 10. Since 10 != 13 it will return false.

This non-strict parsing allows you to combine multiple formatters with one string. The ParsePosition gets updated, so a next Format would start at position 10, ignoring the preceding text.

[David Newton]

Oh, hmm; interesting.