Comment la santé mentale vérifier une date en Java

La façon actuelle est d'utiliser le calendrier de la classe. Il a la setLenient méthode qui permettra de valider la date et de le jeter et d'exception si elle est hors de portée, comme dans votre exemple.

Oublié d'ajouter:
Si vous obtenez un calendrier de l'instance et réglez l'heure à l'aide de votre date, c'est comment vous obtenez la validation.

Calendar cal = Calendar.getInstance();
cal.setLenient(false);
cal.setTime(yourDate);
try {
    cal.getTime();
}
catch (Exception e) {
  System.out.println("Invalid date");
}

Comme indiqué par @Maglob, l'approche de base est de tester la conversion de la chaîne de date à l'aide de SimpleDateFormat.analyser. Qui va attraper invalide jour/mois combinaisons comme 2008-02-31.

Cependant, dans la pratique, c'est rarement suffisant car SimpleDateFormat.analyser est extrêmement libéral. Il y a deux comportements vous pourriez être concerné par:

Des caractères non valides dans la chaîne de date
Étonnamment, 2008-02-2x va "passer" comme une date valide avec les paramètres régionaux de format = "aaaa-MM-jj", par exemple. Même lorsque isLenient==false.

Ans: 2, 3 ou 4 chiffres?
Vous pouvez également appliquer à 4 chiffres des années plutôt que de laisser la valeur par défaut SimpleDateFormat comportement (qui interprétera "12-02-31" différemment selon que votre format "aaaa-MM-jj" ou "yy-MM-dd")

Une Stricte Solution avec la Bibliothèque Standard

Donc une chaîne complète à ce jour de test pourrait ressembler à ceci: une combinaison de regex match, et ensuite forcé la date de conversion. Le truc avec les regex est de rendre les paramètres régionaux de l'environnement.

  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);

Noter que la regex suppose la chaîne de format contient uniquement le jour, le mois, l'année, et des caractères de séparation. A côté de cela, le format peut être dans n'importe quel paramètres régionaux de format: "d/MM/yy", "aaaa-MM-jj", et ainsi de suite. La chaîne de format pour les paramètres régionaux actuels pourrait être obtenu comme ceci:

Locale locale = Locale.getDefault();
SimpleDateFormat sdf = (SimpleDateFormat)DateFormat.getDateInstance(DateFormat.SHORT, locale );
String format = sdf.toPattern();

Joda Time - Meilleure Alternative?

J'ai entendu parler de la joda time récemment et j'ai pensé à comparer. Deux points:

1. Semble de mieux en étant strict sur les caractères non valides dans la chaîne de date, à la différence de SimpleDateFormat
2. Ne peut pas voir un moyen d'appliquer à 4 chiffres années encore (mais je suppose que vous pourriez créer votre propre DateTimeFormatter à cet effet)

C'est assez simple à utiliser:

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;
}

tl;dr

Utiliser le le mode strict sur java.temps.DateTimeFormatter pour analyser un LocalDate. Piège pour le 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.
)

Après l'analyse, vous pouvez vérifier la valeur raisonnable. Par exemple, une date de naissance dans les cent dernières années.

birthDate.isAfter( LocalDate.now().minusYears( 100 ) )

Éviter héritage de date-heure classes

Éviter d'utiliser le gênants vieille date-heure classes livré avec les premières versions de Java. Aujourd'hui supplanté par le java.le temps classes.

LocalDate & DateTimeFormatter & ResolverStyle

La LocalDate classe représente une date uniquement de la valeur, sans le temps de la journée et sans fuseau horaire.

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.temps.DateTimeFormatter classe peut être définie pour analyser des chaînes avec l'un des trois clémence modes définis dans le ResolverStyle enum. Nous insérer une ligne dans le code ci-dessus pour essayer chacun des modes.

f = f.withResolverStyle ( ResolverStyle.LENIENT );

Les résultats:

• ResolverStyle.LENIENT
  ld: 2000-03-02
• ResolverStyle.SMART
  ld: 2000-02-29
• ResolverStyle.STRICT
  ERREUR: java.temps.format.DateTimeParseException: le Texte "31/02/2000' n'a pas pu être analysée: date non Valide 'FÉVRIER 31'

Nous pouvons voir que dans ResolverStyle.CLÉMENT mode, l'invalide à la date avance d'un nombre équivalent de jours. Dans ResolverStyle.SMART mode (par défaut), une décision logique pour maintenir la date dans le mois et aller avec le dernier jour du mois, le 29 Février d'une année bissextile, comme il n'y a pas de 31 jours dans le mois. Le ResolverStyle.STRICT mode déclenche une exception se plaindre qu'il n'y a aucune date.

Tous les trois de celles-ci sont raisonnables en fonction de votre problème d'affaires et politiques. Les sons comme dans votre cas, vous souhaitez que le mode strict de rejeter la date invalide plutôt que de le régler.

---

Sur java.temps

La java.temps cadre est intégré dans Java 8 et les versions ultérieures. Ces classes permettent d'éviter la pénible vieux héritage date du temps des classes comme java.util.Date, Agenda, & SimpleDateFormat.

La Joda-Time projet, maintenant dans le mode de maintenance, conseille la migration vers le java.le temps classes.

Pour en savoir plus, consultez les Oracle Tutoriel. Et de recherche de Débordement de Pile pour de nombreux exemples et des explications. La spécification est JSR 310.

Vous pouvez échanger java.temps objets directement avec votre base de données. Utiliser un Pilote JDBC compatible avec JDBC 4.2 ou plus tard. Pas besoin de chaînes, pas besoin de java.sql.* classes.

Où obtenir le java.les classes de temps?

• Java SE 8, Java SE 9, et plus tard
  • Intégré.
  • Partie de la norme API Java avec une liasse de mise en œuvre.
  • Java 9 ajoute quelques fonctionnalités mineures et corrections.
• Java SE 6 et Java SE 7
  • Une grande partie de la java.fonction temps est de retour, porté à Java 6 & 7 dans ThreeTen-Backport.
• Android
  • Plus tard, des versions d'Android bundle implémentations de java.les classes de temps.
  • Antérieures d'Android (<26), le ThreeTenABP projet s'adapte ThreeTen-Backport (mentionné ci-dessus). Voir Comment utiliser ThreeTenABP....

La ThreeTen-Extra projet s'étend java.temps avec d'autres classes. Ce projet est un terrain d'essai pour de possibles futurs ajouts à java.temps. Vous pouvez trouver quelques classes utiles ici comme Intervalle, YearWeek, YearQuarter, et plus.

Une alternative stricte de la solution à l'aide de la bibliothèque standard est à effectuer les opérations suivantes:

1) Créer un strict SimpleDateFormat à l'aide de votre modèle

2) tente d'analyser l'utilisateur a entré une valeur à l'aide du format de l'objet

3) en Cas de succès, de reformater, de la Date résultant de (2) en utilisant le même format de date (à partir de (1))

4) Comparer les reformaté date à l'encontre de l'original, la valeur saisie par l'utilisateur. S'ils sont égaux alors la valeur entrée strictement correspond à votre modèle.

De cette façon, vous n'avez pas besoin de créer des expressions régulières - dans mon cas, j'avais besoin de l'appui de tout SimpleDateFormat le modèle de la syntaxe, plutôt que de se limiter à certains types comme des jours, des mois et des années.

Je vous suggérons d'utiliser org.apache.commons.validator.GenericValidator classe de apache.

GenericValidator.isDate(String value, String datePattern, boolean strict);

Remarque: strict de savoir Si ou de ne pas avoir une correspondance exacte de la datePattern.

En supposant que ces deux sont des Chaînes de caractères (sinon ils seraient déjà Dates de validité), voici un moyen:

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);
    }
}

Voici la sortie j'obtiens:

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

Comme vous pouvez le voir, il ne gérer à la fois de votre cas bien.

Deux observations sur l'utilisation de SimpleDateFormat.

elle doit être déclarée comme une instance statique
s'il est déclaré comme statique d'accès doit être synchronisé comme il n'est pas thread-safe

IME qui est mieux que de créer une instance pour chaque analyser d'une date.

Voici ce que j'ai fait pour le Nœud de l'environnement à l'aide de pas de bibliothèques externes:

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); 
   }
}

Et voici comment l'utiliser:

isDateCorrect('2014-02-23')
true

Ici c'est que je voudrais vérifier le format de la date:

 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");
}