web-dev-qa-db-fra.com

Java: vérifie si le format de date de la chaîne en cours est conforme au format requis ou non

Je voulais savoir s'il existe une méthode disponible dans Java qui peut le faire. Sinon, je peux choisir une solution Regex.

J'ai une chaîne d'entrée d'utilisateur qui peut être n'importe quel caractère. Et je veux vérifier que la chaîne d'entrée est conforme au format de date requis ou non .

Comme j'ai entré 20130925 et que le format requis est jj/MM/aaaa donc, dans ce cas, je devrais obtenir faux .

Je ne veux pas convertir cette date, je veux juste vérifier si la chaîne d'entrée est conforme au format de date requis ou non.



J'ai essayé de suivre 

Date date = null;
try {
date = new SimpleDateFormat("dd/MM/yyyy").parse("20130925");
} catch (Exception ex) {
// do something for invalid dateformat
}

mais mon bloc catch (Exception ex) ne parvient pas à intercepter les exceptions générées par SimpleDateFormat.Parse ();

javadate
45
Elvin

Avertissement

Analyser une chaîne avec une date/heure dans un format inconnu est par nature impossible (voyons les choses en face, qu'est-ce que 3/3/3 signifie réellement?!), Tout ce que nous pouvons faire est "au mieux"

Important

Cette solution pas jette une Exception, elle retourne une boolean, ceci est voulu par la conception. Toutes les Exceptions sont utilisées uniquement à titre de mécanisme de garde.

2018

Depuis 2018, Java 8+ dispose de l’API date/heure (et le reste utilise le ThreeTen backport ). La solution reste fondamentalement la même, mais devient légèrement plus compliquée, car nous devons effectuer des contrôles pour:

  • date et l'heure
  • date seulement
  • temps seulement

Cela donne quelque chose comme ...

public static boolean isValidFormat(String format, String value, Locale locale) {
    LocalDateTime ldt = null;
    DateTimeFormatter fomatter = DateTimeFormatter.ofPattern(format, locale);

    try {
        ldt = LocalDateTime.parse(value, fomatter);
        String result = ldt.format(fomatter);
        return result.equals(value);
    } catch (DateTimeParseException e) {
        try {
            LocalDate ld = LocalDate.parse(value, fomatter);
            String result = ld.format(fomatter);
            return result.equals(value);
        } catch (DateTimeParseException exp) {
            try {
                LocalTime lt = LocalTime.parse(value, fomatter);
                String result = lt.format(fomatter);
                return result.equals(value);
            } catch (DateTimeParseException e2) {
                // Debugging purposes
                //e2.printStackTrace();
            }
        }
    }

    return false;
}

Cela fait ce qui suit ...

System.out.println("isValid - dd/MM/yyyy with 20130925 = " + isValidFormat("dd/MM/yyyy", "20130925", Locale.ENGLISH));
System.out.println("isValid - dd/MM/yyyy with 25/09/2013 = " + isValidFormat("dd/MM/yyyy", "25/09/2013", Locale.ENGLISH));
System.out.println("isValid - dd/MM/yyyy with 25/09/2013 12:13:50 = " + isValidFormat("dd/MM/yyyy", "25/09/2013  12:13:50", Locale.ENGLISH));
System.out.println("isValid - yyyy-MM-dd with 2017-18--15 = " + isValidFormat("yyyy-MM-dd", "2017-18--15", Locale.ENGLISH));

sortie...

isValid - dd/MM/yyyy with 20130925 = false
isValid - dd/MM/yyyy with 25/09/2013 = true
isValid - dd/MM/yyyy with 25/09/2013 12:13:50 = false
isValid - yyyy-MM-dd with 2017-18--15 = false

Réponse originale

Essayez simplement et analysez la String à la Date requise en utilisant quelque chose comme SimpleDateFormat

Date date = null;
try {
    SimpleDateFormat sdf = new SimpleDateFormat(format);
    date = sdf.parse(value);
    if (!value.equals(sdf.format(date))) {
        date = null;
    }
} catch (ParseException ex) {
    ex.printStackTrace();
}
if (date == null) {
    // Invalid date format
} else {
    // Valid date format
}

Vous pouvez ensuite simplement écrire une méthode simple qui effectue cette action et renvoie true chaque fois que Date n'est pas null ...

A titre de suggestion ...

_ {Mis à jour avec l'exemple en cours d'exécution} _

Je ne suis pas sûr de ce que vous faites, mais l'exemple suivant ...

import Java.text.ParseException;
import Java.text.SimpleDateFormat;
import Java.util.Date;

public class TestDateParser {

    public static void main(String[] args) {
        System.out.println("isValid - dd/MM/yyyy with 20130925 = " + isValidFormat("dd/MM/yyyy", "20130925"));
        System.out.println("isValid - dd/MM/yyyy with 25/09/2013 = " + isValidFormat("dd/MM/yyyy", "25/09/2013"));
        System.out.println("isValid - dd/MM/yyyy with 25/09/2013 12:13:50 = " + isValidFormat("dd/MM/yyyy", "25/09/2013  12:13:50"));
    }

    public static boolean isValidFormat(String format, String value) {
        Date date = null;
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(format);
            date = sdf.parse(value);
            if (!value.equals(sdf.format(date))) {
                date = null;
            }
        } catch (ParseException ex) {
            ex.printStackTrace();
        }
        return date != null;
    }

}

Sorties (quelque chose comme) ...

Java.text.ParseException: Unparseable date: "20130925"
isValid - dd/MM/yyyy with 20130925 = false
isValid - dd/MM/yyyy with 25/09/2013 = true
isValid - dd/MM/yyyy with 25/09/2013 12:13:50 = false
    at Java.text.DateFormat.parse(DateFormat.Java:366)
    at javaapplication373.JavaApplication373.isValidFormat(JavaApplication373.Java:28)
    at javaapplication373.JavaApplication373.main(JavaApplication373.Java:19)

Pas correcte. Pour isValidFormat ("aaaa-MM-jj", "2017-18--15"); ne lance aucune exception. 

isValid - yyyy-MM-dd", "2017-18--15 = false

Semble fonctionner comme prévu pour moi - la méthode ne repose pas (ni ne jette) l'exception à elle seule pour effectuer son opération

76
MadProgrammer

Pour votre cas, vous pouvez utiliser regex:

boolean checkFormat;

if (input.matches("([0-9]{2})/([0-9]{2})/([0-9]{4})"))
    checkFormat=true;
else
   checkFormat=false;

Pour une plus grande portée ou si vous voulez une solution flexible, référez-vous à MadProgrammer's answer.

Modifier

Presque 5 ans après la publication de cette réponse, je me rends compte que c'est une façon stupide de valider un format de date. Mais je vais laisser cela ici pour dire aux gens que l'utilisation de regex pour valider une date est inacceptable

26
Baby

Vous pouvez essayer ceci avec une simple validation du format de date

 public Date validateDateFormat(String dateToValdate) {

    SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yyyy HHmmss");
    //To make strict date format validation
    formatter.setLenient(false);
    Date parsedDate = null;
    try {
        parsedDate = formatter.parse(dateToValdate);
        System.out.println("++validated DATE TIME ++"+formatter.format(parsedDate));

    } catch (ParseException e) {
        //Handle exception
    }
    return parsedDate;
}
17
jAnA
DateFormat formatter = new SimpleDateFormat("dd/MM/yyyy");
formatter.setLenient(false);
try {
    Date date= formatter.parse("02/03/2010");
} catch (ParseException e) {
    //If input date is in different format or invalid.
}

formatter.setLenient (false) appliquera une correspondance stricte.

Si vous utilisez Joda-Time - 

private boolean isValidDate(String dateOfBirth) {
        boolean valid = true;
        try {
            DateTimeFormatter formatter = DateTimeFormat.forPattern("dd/MM/yyyy");
            DateTime dob = formatter.parseDateTime(dateOfBirth);
        } catch (Exception e) {
            valid = false;
        }
        return valid;
    }
9
tiwari.vikash

Par exemple, si vous souhaitez que le format de date soit "03.11.2017"

 if (String.valueOf(DateEdit.getText()).matches("([1-9]{1}|[0]{1}[1-9]{1}|[1]{1}[0-9]{1}|[2]{1}[0-9]{1}|[3]{1}[0-1]{1})" +
           "([.]{1})" +
           "([0]{1}[1-9]{1}|[1]{1}[0-2]{1}|[1-9]{1})" +
           "([.]{1})" +
           "([20]{2}[0-9]{2})"))
           checkFormat=true;
 else
           checkFormat=false;

 if (!checkFormat) {
 Toast.makeText(getApplicationContext(), "incorrect date format! Ex.23.06.2016", Toast.LENGTH_SHORT).show();
                }
0
kksal55

Voici une méthode simple:

public static boolean checkDatePattern(String padrao, String data) {
    try {
        SimpleDateFormat format = new SimpleDateFormat(padrao, LocaleUtils.DEFAULT_LOCALE);
        format.parse(data);
        return true;
    } catch (ParseException e) {
        return false;
    }
}
0
Alberto Cerqueira

Une combinaison du regex et de SimpleDateFormat est la bonne réponse, je crois. SimpleDateFormat n'intercepte pas l'exception si les composants individuels ne sont pas valides, ce qui signifie que le format .__ est défini: aaaa-mm-jj , Entrée: 201-0-12 Aucune exception ne sera levée. Mais avec la regex suggérée par Sok Pomaranczowy, Baby s’occupe de ce cas particulier.

0
Pramit