Me parece curioso que la forma más obvia de crear Dateobjetos en Java haya quedado obsoleta y parece haber sido "sustituida" por un calendario poco obvio de usar.
¿Cómo se comprueba que una fecha, dada como una combinación de día, mes y año, es una fecha válida?
Por ejemplo, 2008-02-31 (como en aaaa-mm-dd) sería una fecha no válida.
Respuestas:
La forma actual es usar la clase de calendario. Tiene el método setLenient que validará la fecha y lanzará una excepción si está fuera de rango como en su ejemplo.
Olvidé agregar: Si obtiene una instancia de calendario y establece la hora usando su fecha, así es como obtiene la validación.
Calendar cal = Calendar.getInstance();
cal.setLenient(false);
cal.setTime(yourDate);
try {
cal.getTime();
}
catch (Exception e) {
System.out.println("Invalid date");
}
java.util.Date, java.util.Calendary java.text.SimpleDateFormatahora son heredadas , suplantadas por las clases java.time integradas en Java 8 y posteriores. Consulte el tutorial de Oracle .
La clave es df.setLenient (falso); . Esto es más que suficiente para casos simples. Si está buscando una biblioteca más robusta (lo dudo) y / o alternativas como joda-time, mire la respuesta del usuario "tardate"
final static String DATE_FORMAT = "dd-MM-yyyy";
public static boolean isDateValid(String date)
{
try {
DateFormat df = new SimpleDateFormat(DATE_FORMAT);
df.setLenient(false);
df.parse(date);
return true;
} catch (ParseException e) {
return false;
}
}
setLeniento no: SimpleDateFormatsiempre analizará hasta que el patrón coincida e ignorará el resto de la cadena, por lo que obtendrá 201como año.
java.util.Date, java.util.Calendary java.text.SimpleDateFormatahora son heredadas , suplantadas por las clases java.time integradas en Java 8 y versiones posteriores. Consulte el tutorial de Oracle .
Como lo muestra @Maglob, el enfoque básico es probar la conversión de cadena a fecha usando SimpleDateFormat.parse . Eso detectará combinaciones inválidas de día / mes como 2008-02-31.
Sin embargo, en la práctica, eso rara vez es suficiente, ya que SimpleDateFormat.parse es extremadamente liberal. Hay dos comportamientos que pueden preocuparle:
Caracteres no válidos en la cadena de fecha Sorprendentemente, 2008-02-2x "pasará" como una fecha válida con el formato local = "aaaa-MM-dd", por ejemplo. Incluso cuando isLenient == false.
Años: ¿2, 3 o 4 dígitos? También es posible que desee aplicar años de 4 dígitos en lugar de permitir el comportamiento predeterminado de SimpleDateFormat (que interpretará "12-02-31" de manera diferente dependiendo de si su formato era "aaaa-MM-dd" o "aa-MM-dd" )
Entonces, una prueba de cadena completa hasta la fecha podría verse así: una combinación de coincidencia de expresiones regulares y luego una conversión de fecha forzada. El truco con la expresión regular es hacerlo compatible con la configuración regional.
Date parseDate(String maybeDate, String format, boolean lenient) {
Date date = null;
// test date string matches format structure using regex
// - weed out illegal characters and enforce 4-digit year
// - create the regex based on the local format string
String reFormat = Pattern.compile("d+|M+").matcher(Matcher.quoteReplacement(format)).replaceAll("\\\\d{1,2}");
reFormat = Pattern.compile("y+").matcher(reFormat).replaceAll("\\\\d{4}");
if ( Pattern.compile(reFormat).matcher(maybeDate).matches() ) {
// date string matches format structure,
// - now test it can be converted to a valid date
SimpleDateFormat sdf = (SimpleDateFormat)DateFormat.getDateInstance();
sdf.applyPattern(format);
sdf.setLenient(lenient);
try { date = sdf.parse(maybeDate); } catch (ParseException e) { }
}
return date;
}
// used like this:
Date date = parseDate( "21/5/2009", "d/M/yyyy", false);
Tenga en cuenta que la expresión regular asume que la cadena de formato contiene solo día, mes, año y caracteres separadores. Aparte de eso, el formato puede estar en cualquier formato local: "d / MM / aa", "aaaa-MM-dd", etc. La cadena de formato para la configuración regional actual podría obtenerse así:
Locale locale = Locale.getDefault();
SimpleDateFormat sdf = (SimpleDateFormat)DateFormat.getDateInstance(DateFormat.SHORT, locale );
String format = sdf.toPattern();
He oído hablar de joda time recientemente y pensé en comparar. Dos puntos:
Es bastante simple de usar:
import org.joda.time.format.*;
import org.joda.time.DateTime;
org.joda.time.DateTime parseDate(String maybeDate, String format) {
org.joda.time.DateTime date = null;
try {
DateTimeFormatter fmt = DateTimeFormat.forPattern(format);
date = fmt.parseDateTime(maybeDate);
} catch (Exception e) { }
return date;
}
Date, SimpleDateFormat, etc.) ahora son suplantados por los modernos java.time clases. Asimismo, el proyecto Joda-Time está en modo de mantenimiento y aconseja la migración a las clases java.time .
Puede utilizar SimpleDateFormat
Por ejemplo algo como:
boolean isLegalDate(String s) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
sdf.setLenient(false);
return sdf.parse(s, new ParsePosition(0)) != null;
}
java.util.Date, java.util.Calendary java.text.SimpleDateFormatahora son heredadas , suplantadas por las clases java.time integradas en Java 8 y versiones posteriores. Consulte el tutorial de Oracle .
Utilice el modo estricto en java.time.DateTimeFormatterllegar a un análisis LocalDate. Trampa para el DateTimeParseException.
LocalDate.parse( // Represent a date-only value, without time-of-day and without time zone.
"31/02/2000" , // Input string.
DateTimeFormatter // Define a formatting pattern to match your input string.
.ofPattern ( "dd/MM/uuuu" )
.withResolverStyle ( ResolverStyle.STRICT ) // Specify leniency in tolerating questionable inputs.
)
Después de analizar, puede verificar el valor razonable. Por ejemplo, una fecha de nacimiento dentro de los últimos cien años.
birthDate.isAfter( LocalDate.now().minusYears( 100 ) )
Evite el uso de las problemáticas clases de fecha y hora que se incluyen con las primeras versiones de Java. Ahora reemplazado por las clases java.time .
LocalDate& DateTimeFormatter&ResolverStyleLa LocalDateclase representa un valor de solo fecha sin hora del día y sin zona horaria.
String input = "31/02/2000";
DateTimeFormatter f = DateTimeFormatter.ofPattern ( "dd/MM/uuuu" );
try {
LocalDate ld = LocalDate.parse ( input , f );
System.out.println ( "ld: " + ld );
} catch ( DateTimeParseException e ) {
System.out.println ( "ERROR: " + e );
}
La java.time.DateTimeFormatterclase se puede configurar para analizar cadenas con cualquiera de los tres modos de indulgencia definidos en la ResolverStyleenumeración. Insertamos una línea en el código anterior para probar cada uno de los modos.
f = f.withResolverStyle ( ResolverStyle.LENIENT );
Los resultados:
ResolverStyle.LENIENTResolverStyle.SMARTResolverStyle.STRICTPodemos ver que en el ResolverStyle.LENIENTmodo, la fecha inválida se adelanta un número equivalente de días. En el ResolverStyle.SMARTmodo (el predeterminado), se toma una decisión lógica para mantener la fecha dentro del mes y continuar con el último día posible del mes, el 29 de febrero en un año bisiesto, ya que no hay día 31 en ese mes. El ResolverStyle.STRICTmodo lanza una excepción quejándose de que no existe tal fecha.
Los tres son razonables según el problema y las políticas de su negocio. Parece que, en su caso, desea que el modo estricto rechace la fecha no válida en lugar de ajustarla.
El marco java.time está integrado en Java 8 y versiones posteriores. Estas clases suplantar la vieja problemáticos heredados clases de fecha y hora como java.util.Date, Calendar, y SimpleDateFormat.
Para obtener más información, consulte el tutorial de Oracle . Y busque Stack Overflow para obtener muchos ejemplos y explicaciones. La especificación es JSR 310 .
El proyecto Joda-Time , ahora en modo de mantenimiento , aconseja la migración a las clases java.time .
Puede intercambiar objetos java.time directamente con su base de datos. Utilice un controlador JDBC compatible con JDBC 4.2 o posterior. No se necesitan cuerdas, no se necesitan java.sql.*clases.
¿Dónde obtener las clases java.time?
El proyecto ThreeTen-Extra extiende java.time con clases adicionales. Este proyecto es un campo de pruebas para posibles adiciones futuras a java.time. Usted puede encontrar algunas clases útiles aquí, como Interval, YearWeek, YearQuarter, y más .
Con la API de fecha y hora ( clases java.time ) integrada en Java 8 y versiones posteriores, puede usar la LocalDateclase.
public static boolean isDateValid(int year, int month, int day) {
boolean dateIsValid = true;
try {
LocalDate.of(year, month, day);
} catch (DateTimeException e) {
dateIsValid = false;
}
return dateIsValid;
}
ResolverStyle.SMARTque ajusta el valor resultante a una fecha válida en lugar de lanzar una excepción. Por lo tanto, este código no logrará el objetivo de la Pregunta. Consulte mi respuesta, por ejemplo, y para obtener una solución ResolverStyle.STRICT.
Una solución alternativa estricta que utiliza la biblioteca estándar es realizar lo siguiente:
1) Cree un SimpleDateFormat estricto usando su patrón
2) Intente analizar el valor ingresado por el usuario usando el objeto de formato
3) Si tiene éxito, vuelva a formatear la fecha resultante de (2) utilizando el mismo formato de fecha (de (1))
4) Compare la fecha reformateada con el valor original introducido por el usuario. Si son iguales, el valor ingresado coincide estrictamente con su patrón.
De esta manera, no necesita crear expresiones regulares complejas; en mi caso, necesitaba admitir toda la sintaxis de patrones de SimpleDateFormat, en lugar de limitarme a ciertos tipos, como solo días, meses y años.
Sobre la base de la respuesta de Aravind para solucionar el problema señalado por ceklock en su comentario , agregué un método para verificar que dateStringno contiene ningún carácter no válido.
Así es como lo hago:
private boolean isDateCorrect(String dateString) {
try {
Date date = mDateFormatter.parse(dateString);
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
return matchesOurDatePattern(dateString); //added my method
}
catch (ParseException e) {
return false;
}
}
/**
* This will check if the provided string matches our date format
* @param dateString
* @return true if the passed string matches format 2014-1-15 (YYYY-MM-dd)
*/
private boolean matchesDatePattern(String dateString) {
return dateString.matches("^\\d+\\-\\d+\\-\\d+");
}
Creo que lo más simple es convertir una cadena en un objeto de fecha y volver a convertirla en una cadena. La cadena de fecha dada está bien si ambas cadenas aún coinciden.
public boolean isDateValid(String dateString, String pattern)
{
try
{
SimpleDateFormat sdf = new SimpleDateFormat(pattern);
if (sdf.format(sdf.parse(dateString)).equals(dateString))
return true;
}
catch (ParseException pe) {}
return false;
}
Suponiendo que ambos son cadenas (de lo contrario, ya serían fechas válidas), aquí hay una forma:
package cruft;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateValidator
{
private static final DateFormat DEFAULT_FORMATTER;
static
{
DEFAULT_FORMATTER = new SimpleDateFormat("dd-MM-yyyy");
DEFAULT_FORMATTER.setLenient(false);
}
public static void main(String[] args)
{
for (String dateString : args)
{
try
{
System.out.println("arg: " + dateString + " date: " + convertDateString(dateString));
}
catch (ParseException e)
{
System.out.println("could not parse " + dateString);
}
}
}
public static Date convertDateString(String dateString) throws ParseException
{
return DEFAULT_FORMATTER.parse(dateString);
}
}
Aquí está la salida que obtengo:
java cruft.DateValidator 32-11-2010 31-02-2010 04-01-2011
could not parse 32-11-2010
could not parse 31-02-2010
arg: 04-01-2011 date: Tue Jan 04 00:00:00 EST 2011
Process finished with exit code 0
Como puede ver, maneja bien ambos casos.
Esto está funcionando muy bien para mí. Enfoque sugerido anteriormente por Ben.
private static boolean isDateValid(String s) {
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
try {
Date d = asDate(s);
if (sdf.format(d).equals(s)) {
return true;
} else {
return false;
}
} catch (ParseException e) {
return false;
}
}
parece que SimpleDateFormat no está comprobando el patrón estrictamente incluso después de setLenient (false); se aplica el método en él, por lo que he utilizado el método siguiente para validar si la fecha ingresada es una fecha válida o no según el patrón proporcionado.
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
public boolean isValidFormat(String dateString, String pattern) {
boolean valid = true;
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
try {
formatter.parse(dateString);
} catch (DateTimeParseException e) {
valid = false;
}
return valid;
}
Dos comentarios sobre el uso de SimpleDateFormat.
debe declararse como una instancia estática si se declara como acceso estático debe sincronizarse ya que no es seguro para subprocesos
IME que es mejor que instanciar una instancia para cada análisis de una fecha.
Los métodos anteriores de análisis de fechas son agradables, acabo de agregar una nueva verificación en los métodos existentes que verifican dos veces la fecha convertida con la fecha original usando formater, por lo que funciona para casi todos los casos, como verifiqué. por ejemplo, el 29/02/2013 no es una fecha válida. La función dada analiza la fecha de acuerdo con los formatos de fecha aceptables actuales. Devuelve verdadero si la fecha no se analiza correctamente.
public final boolean validateDateFormat(final String date) {
String[] formatStrings = {"MM/dd/yyyy"};
boolean isInvalidFormat = false;
Date dateObj;
for (String formatString : formatStrings) {
try {
SimpleDateFormat sdf = (SimpleDateFormat) DateFormat.getDateInstance();
sdf.applyPattern(formatString);
sdf.setLenient(false);
dateObj = sdf.parse(date);
System.out.println(dateObj);
if (date.equals(sdf.format(dateObj))) {
isInvalidFormat = false;
break;
}
} catch (ParseException e) {
isInvalidFormat = true;
}
}
return isInvalidFormat;
}
Esto es lo que hice para el entorno Node sin usar bibliotecas externas:
Date.prototype.yyyymmdd = function() {
var yyyy = this.getFullYear().toString();
var mm = (this.getMonth()+1).toString(); // getMonth() is zero-based
var dd = this.getDate().toString();
return zeroPad([yyyy, mm, dd].join('-'));
};
function zeroPad(date_string) {
var dt = date_string.split('-');
return dt[0] + '-' + (dt[1][1]?dt[1]:"0"+dt[1][0]) + '-' + (dt[2][1]?dt[2]:"0"+dt[2][0]);
}
function isDateCorrect(in_string) {
if (!matchesDatePattern) return false;
in_string = zeroPad(in_string);
try {
var idate = new Date(in_string);
var out_string = idate.yyyymmdd();
return in_string == out_string;
} catch(err) {
return false;
}
function matchesDatePattern(date_string) {
var dateFormat = /[0-9]+-[0-9]+-[0-9]+/;
return dateFormat.test(date_string);
}
}
Y así es como se usa:
isDateCorrect('2014-02-23')
true
// to return valid days of month, according to month and year
int returnDaysofMonth(int month, int year) {
int daysInMonth;
boolean leapYear;
leapYear = checkLeap(year);
if (month == 4 || month == 6 || month == 9 || month == 11)
daysInMonth = 30;
else if (month == 2)
daysInMonth = (leapYear) ? 29 : 28;
else
daysInMonth = 31;
return daysInMonth;
}
// to check a year is leap or not
private boolean checkLeap(int year) {
Calendar cal = Calendar.getInstance();
cal.set(Calendar.YEAR, year);
return cal.getActualMaximum(Calendar.DAY_OF_YEAR) > 365;
}
Aquí es donde verificaría el formato de fecha:
public static boolean checkFormat(String dateTimeString) {
return dateTimeString.matches("^\\d{4}-\\d{2}-\\d{2}") || dateTimeString.matches("^\\d{4}-\\d{2}-\\d{2}\\s\\d{2}:\\d{2}:\\d{2}")
|| dateTimeString.matches("^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}") || dateTimeString
.matches("^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z") ||
dateTimeString.matches("^\\d{4}-\\d{2}-\\d{2}\\s\\d{2}:\\d{2}:\\d{2}Z");
}
public static String detectDateFormat(String inputDate, String requiredFormat) {
String tempDate = inputDate.replace("/", "").replace("-", "").replace(" ", "");
String dateFormat;
if (tempDate.matches("([0-12]{2})([0-31]{2})([0-9]{4})")) {
dateFormat = "MMddyyyy";
} else if (tempDate.matches("([0-31]{2})([0-12]{2})([0-9]{4})")) {
dateFormat = "ddMMyyyy";
} else if (tempDate.matches("([0-9]{4})([0-12]{2})([0-31]{2})")) {
dateFormat = "yyyyMMdd";
} else if (tempDate.matches("([0-9]{4})([0-31]{2})([0-12]{2})")) {
dateFormat = "yyyyddMM";
} else if (tempDate.matches("([0-31]{2})([a-z]{3})([0-9]{4})")) {
dateFormat = "ddMMMyyyy";
} else if (tempDate.matches("([a-z]{3})([0-31]{2})([0-9]{4})")) {
dateFormat = "MMMddyyyy";
} else if (tempDate.matches("([0-9]{4})([a-z]{3})([0-31]{2})")) {
dateFormat = "yyyyMMMdd";
} else if (tempDate.matches("([0-9]{4})([0-31]{2})([a-z]{3})")) {
dateFormat = "yyyyddMMM";
} else {
return "Pattern Not Added";
//add your required regex
}
try {
String formattedDate = new SimpleDateFormat(requiredFormat, Locale.ENGLISH).format(new SimpleDateFormat(dateFormat).parse(tempDate));
return formattedDate;
} catch (Exception e) {
//
return "";
}
}
Con el formato de fecha 'heredado', podemos formatear el resultado y compararlo con la fuente.
public boolean isValidFormat(String source, String pattern) {
SimpleDateFormat sd = new SimpleDateFormat(pattern);
sd.setLenient(false);
try {
Date date = sd.parse(source);
return date != null && sd.format(date).equals(source);
} catch (Exception e) {
return false;
}
}
Este execerpt dice 'falso' a la fuente = 01.01.04 con el patrón '01 .01.2004 '
setLenient en false si desea una validación estricta
public boolean isThisDateValid(String dateToValidate, String dateFromat){
if(dateToValidate == null){
return false;
}
SimpleDateFormat sdf = new SimpleDateFormat(dateFromat);
sdf.setLenient(false);
try {
//if not valid, it will throw ParseException
Date date = sdf.parse(dateToValidate);
System.out.println(date);
} catch (ParseException e) {
e.printStackTrace();
return false;
}
return true;
}