Java: vérifiez que le format de date de la chaîne courante est conforme au format requis ou non [dupliquer]

cette question a déjà une réponse ici:

je voulais savoir s'il y a une méthode disponible dans Java qui peut faire cela.Sinon, je peux opter pour la solution Regex.



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

comme j'ai entré 20130925 et mon format requis est JJ/MM/AAAA donc, pour 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 selon le format de date ou pas.





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) est incapable de saisir les exceptions générées par SimpleDateFormat.Parse ();

42
demandé sur Elvin 2013-11-27 05:56:21
la source

9 ответов

clause de non-responsabilité

analyser une chaîne de caractères en fonction de la date et de la valeur temporelle dans un format inconnu est en soi impossible (soyons francs, que signifie réellement 3/3/3 ?!), tout ce que nous pouvons faire est de "best effort"

Important

Cette solution n'est pas jeter Exception , il renvoie un boolean , c'est par la conception. Tout Exception est utilisé uniquement comme mécanisme de garde.

2018

Puisqu'il est maintenant 2018 et Java 8+ a la date / heure API (et le reste ont le backport ThreeTen ). La solution reste essentiellement la même, mais devient un peu plus compliquée, car nous devons effectuer des contrôles pour:

  • date et heure
  • date seulement
  • temps seulement

cela ressemble à quelque chose...

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));
"1519180920 de 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

Simple essayer et d'analyser les String à la Date 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 pourriez alors simplement écrire une méthode simple qui a effectué cette action et retourné true alors que jamais Date n'était pas NULL...

comme suggestion...

mis à Jour avec l'exécution de l'exemple

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 correct. Pour isValidFormat ("AAAA-MM-JJ"," 2017-18--15"); ne pas jeter D'Exception.

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

semble fonctionner comme prévu pour moi - la méthode ne repose pas sur (ni ne jette) l'exception seule pour effectuer son fonctionnement

69
répondu MadProgrammer 2018-05-23 01:24:53
la source

pour votre valise, 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 réponse.

Modifier

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

21
répondu Baby 2018-09-18 06:03:51
la source

vous pouvez essayer cette date au format simple valdation

 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;
}
15
répondu jAnA 2014-10-01 07:22:41
la source
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.
}

formateur.setLenient (false) imposera 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;
    }
7
répondu tiwari.vikash 2015-03-16 23:43:42
la source

une combinaison de regex et SimpleDateFormat est la bonne réponse, je crois. SimpleDateFormat ne capte pas l'exception si les composants individuels sont invalides signification, Format défini: AAAA-mm-JJ entrée: 201-0-12 Aucune exception n'est levée.Cette affaire aurait dû être traitée. Mais avec le regex comme suggéré par Sok Pomaranczowy et bébé prendra soin de ce cas particulier.

0
répondu Pramit 2015-05-04 20:43:21
la source

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
répondu Alberto Cerqueira 2016-12-06 16:50:42
la source

par exemple, si vous voulez que le format de la 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
répondu kksal55 2017-09-11 00:42:57
la source

Regex peut être utilisé pour ceci avec quelques informations détaillées pour la validation, par exemple ce code peut être utilisé pour valider n'importe quelle date dans le format (JJ/MM/AAAA) avec la date appropriée et la valeur de mois et année entre (1950-2050)

    public Boolean checkDateformat(String dateToCheck){   
        String rex="([0]{1}[1-9]{1}|[1-2]{1}[0-9]{1}|[3]{1}[0-1]{1})+
        \/([0]{1}[1-9]{1}|[1]{1}[0-2]{2})+
        \/([1]{1}[9]{1}[5-9]{1}[0-9]{1}|[2]{1}[0]{1}([0-4]{1}+
        [0-9]{1}|[5]{1}[0]{1}))";

        return(dateToCheck.matches(rex));
    }
-1
répondu Tonmoy 2017-01-02 13:48:46
la source

puisque je ne peux pas commenter, j'ajouterai à la réponse de @Jonjongot que vous pouvez simplement

return input.matches("([0-9]{2})/([0-9]{2})/([0-9]{4})")
-2
répondu Sok Pomaranczowy 2014-12-31 12:06:19
la source

Autres questions sur