Wie um zu überprüfen, die Gültigkeit von Datums-String?

In mein Projekt, ich brauche, um zu überprüfen, ob ein Datum-string auswertet, zu einem richtigen Date-Objekt. Ich habe entschieden zu erlauben, yyyy-MM-dd, und Datum-Formate [(Jahr, Monat, Datum) (Jahr, Monat, Tag, STD, min)]. Wie kann ich prüfen, ob Sie gültig sind ? Mein code gibt null für "1980-01-01" und einige seltsame Daten (wie 3837.05.01) whon geben einen string, getrennt durch Kommas :

private Date parseDate(String date){
    Date data = null;

    //yyy-mm-dd
    try {
        DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
        df.setLenient(false);
        df.parse(date);
        return data;
    }
    catch (Exception e) {
        try{
            int[] datArr = parseStringForDate(date);
            int len = datArr.length;
            //year, month, day
            if(len == 3){
                return new Date(datArr[0], datArr[1], datArr[2]);
            }
            //year, montd, day, hours, mins
            else if(len ==5){
                return new Date(datArr[0], datArr[1], datArr[2], datArr[3], datArr[4]);
            }
            //year, month, day, hours, mins, secs
            else if(len == 6){
                return new Date(datArr[0], datArr[1], datArr[2], datArr[3], datArr[4], datArr[5]);
            }
            else {
                return data;
            }
        }
        catch (Exception f){
            return data;
        }
    }
}

private int[] parseStringForDate(String s){
    String[] sArr = s.split(",");
    int[] dateArr = new int[sArr.length];

    for(int i=0; i< dateArr.length; i++){
        dateArr[i] = Integer.parseInt(sArr[i]);
    }

    return dateArr;
}

Ich erinnere mich, dass ich hatte, um zu subtrahieren 1900 von Jahr Datum, aber ich sehe auch, dass Monat ist anders etc, und ich möchte vermeiden, überprüfen Sie jedes element meines Arrays mit int-Werten, die aus den Datums-string. Ist es möglich zu analysieren, die Sie automatisch in Kalender-oder date-Objekt ?

Herzlich willkommen auf Stack Overflow! Diese lösen nicht dein problem direkt, aber du bist mit try-catch-Blöcke zu implementieren, Ihre Logik, und Sie können finden, die Dinge werden klarer, wenn Sie behalten uns Ausnahmen bei außergewöhnlichen Bedingungen.
Mehr relevant zu deinem problem: was ist yyy-mm-dd format? Würde "999-10-10" bedeutet, Oktober 10, 1999? Oder Oktober 10, 999? Oktober 10, 2099?
Hoppla, es sollte yyyy

InformationsquelleAutor dbnazz | 2010-10-24

7

Können Sie konstruieren "=SimpleDateFormat Objekte für Ihre verschiedenen String-Formate wie dieses (Rückkehr null wenn der parameter nicht analysiert werden, wie ein gültiges Datum):
```
//Initializing possibleFormats somewhere only once
SimpleDateFormat[] possibleFormats = new SimpleDateFormat[] {
  new SimpleDateFormat("yyyy-MM-dd"),
  new SimpleDateFormat("yyyy,MM,dd"),
  new SimpleDateFormat("yyyy,MM,dd,HH,mm") };
for (SimpleDateFormat format: possibleFormats)
{
  format.setLenient(false);
}
//initializing ends

public Date parseDate(String date) {
  Date retVal = null;
  int index = 0;
  while (retVal == null && index < possibleFormats.length) {
    try {
      retVal = possibleFormats[index++].parse(date);
    } catch (ParseException ex) { /* Do nothing */ }
  }
  return retVal;
}
```
- BTW, können Sie eine for-Schleife verwenden (for (Format f: possibleFormat) { ... }) statt alle, die while-Schleife Logik.
- Wow, das ist eine schöne Herangehensweise an das problem. Das einzige Problem, das ich sehe ist, dass die OP gesprochen, immer seltsamen Datumsangaben in 1980 und 3837 aber Sie nur schauen, um zu sehen, wenn das Datum null ist.
- dieser endet in einer nie endenden Schleife, wenn die ParseException geworfen wird, ist - soll-Inkrement außerhalb des try-catch. dies wird auch Parsen Ungültiger Datumsangaben als 2010-14-24 (zurück Feb. 24, 2011) - " = SimpleDateFormat gesetzt werden muss, nicht nachsichtig.
- Ich mag nicht mit return in der Mitte einer für, das ist, warum ich eine Weile. @Carlos: du hast Recht, danke, ich habe aktualisiert, der code.
- Beenden Sie früh morgens aus einer for-Schleife mit break.
- sicher, aber ich brauche eine extra, wenn innerhalb der für so in meine Meinung mit, das ist einfacher und 'verständlich' in diesem Fall (die gesamte Logik an einer Stelle). Aber, wieder, IMHO 🙂
InformationsquelleAutor Csaba_H
1

Sie tun dies der falsche Weg. Sie verwenden sollten,"=SimpleDateFormat.
```
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
try {
    Date test = sdf.parse(input);
} catch (ParseException pe) {
   //Date is invalid, try next format
}
```
- Okay, ich sehe, Sie haben aktualisiert. Aber die OP ist über irgendeine Art von drei-stelligen Jahreszahl, also diese Antwort kann nicht hilfreich sein.
- Es nicht zurück null auf Fehler.
- Wenn das der Fall ist und nicht ein Tippfehler ist, denke ich, es ist immer noch sinnvoll, Sie könnten aufgeteilt auf die gültige Trennzeichen und Schreibe eine 1 oder eine 2, je nach Wert Lesen, dann anwenden " = SimpleDateFormat zu lassen, kümmern sich um Schaltjahre und so weiter.
- das war ein Tippfehler, sorry
InformationsquelleAutor Vinko Vrsalovic

Für alle knallen durch die im Jahr 2017 oder später, hier ist das Java-8-Lösung:

private static DateTimeFormatter[] possibleFormats = {
    DateTimeFormatter.ofPattern("uuuu-MM-dd").withResolverStyle(ResolverStyle.STRICT),
    DateTimeFormatter.ofPattern("uuuu,MM,dd").withResolverStyle(ResolverStyle.STRICT),
    DateTimeFormatter.ofPattern("uuuu,MM,dd,HH,mm").withResolverStyle(ResolverStyle.STRICT),
    DateTimeFormatter.ofPattern("uuuu,MM,dd,HH,mm,ss").withResolverStyle(ResolverStyle.STRICT)
};

public Optional<LocalDate> parseDate(String date) {
    for (DateTimeFormatter format : possibleFormats) {
        try {
            LocalDate result = LocalDate.parse(date, format);
            return Optional.of(result);
        } catch (DateTimeParseException dtpe) {
            //ignore, try next format
        }
    }
    return Optional.empty();
}

Mit DateTimeFormatter können Sie sicher lassen Sie das array der Formatierer werden statisch, auch in einer Multithreading-Umgebung: im Gegensatz zu SimpleDateFormat eine DateTimeFormatter ist thread-sicher.

Einen LocalDate ist ein Datum ohne Zeit, also, wenn irgendwelche Stunden und Minuten waren in der Zeichenfolge, sind Sie verloren. Um die Stunden, Minuten und Sekunden müssen Sie auch eine LocalDateTime, und dann müssen Sie ein paar Tricks, um die Analyse der Arbeit in den Fällen, in denen keine Stunden und Minuten in der Zeichenfolge. Sie können entweder versuchen, beide LocalDate.parse() und LocalDateTime.parse() oder erstellen Sie vielleicht einen Formatierer hat einen Standard für Stunden zu verwenden, wenn Sie nicht in der Zeichenfolge. DateTimeFormatterBuilder tun kann.

InformationsquelleAutor Ole V.V.

Nur um zu zeigen das Endergebnis, Dank Csaba_H und Steve Kuo.

private Date parseDate(String date){

    SimpleDateFormat[] possibleFormats = new SimpleDateFormat[] {
        new SimpleDateFormat("yyyy-MM-dd"),
        new SimpleDateFormat("yyyy,MM,dd"),
        new SimpleDateFormat("yyyy,MM,dd,HH,mm") };

    Date retVal = null;
    for (SimpleDateFormat f: possibleFormats) {
        f.setLenient(false);
        try {
            retVal = f.parse(date);
        } catch (ParseException e) {}
    }
    return retVal;
}

Ich bin froh, Ihnen zu helfen. Ein letztes Wort: Sie sollten Konstrukt der possibleFormats nur einmal (vielleicht ist statisch, wenn Sie nicht in einem multi-threaded context) zu vermeiden, konstruieren viele 'throw-away' - Objekten; und sollten Sie wieder nach einem erfolgreichen Parsen, um zu vermeiden, die unnötige Ausnahme Schöpfung und fangen.

InformationsquelleAutor dbnazz

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.