Analysieren Sie jedes Datum in Java

Ich weiß, dass diese Frage ziemlich oft gestellt wird, und offensichtlich können Sie kein beliebiges Datum analysieren. Ich finde jedoch, dass die Python-Dateutil-Bibliothek in der Lage ist, jedes Datum zu analysieren, das ich darauf wirfe, während es absolut keinen Aufwand erfordert, eine Datumsformatzeichenfolge herauszufinden. Joda-Zeit wird immer als großartiger Java-Datums-Parser verkauft, aber Sie müssen immer noch entscheiden, in welchem ​​Format Ihr Datum vorliegt, bevor Sie ein Format auswählen (oder ein eigenes erstellen). Sie können nicht einfach DateFormatter.parse (mydate) aufrufen und auf magische Weise ein Date-Objekt zurückerhalten.

Zum Beispiel wird das Datum "Mi Mar 04 05:09:06 GMT-06: 00 2009" ordnungsgemäß mit Python-Dateutil analysiert:

import dateutil.parser
print dateutil.parser.parse('Wed Mar 04 05:09:06 GMT-06:00 2009')

Der folgende Joda-Zeitaufruf funktioniert jedoch nicht:

    String date = "Wed Mar 04 05:09:06 GMT-06:00 2009";
    DateTimeFormatter fmt = ISODateTimeFormat.dateTime();
    DateTime dt = fmt.parseDateTime(date);
    System.out.println(date);

Das Erstellen eines eigenen DateTimeFormatter macht den Zweck zunichte, da dies mit der Verwendung von SimpleDateFormatter mit der richtigen Formatzeichenfolge identisch zu sein scheint.

Gibt es eine vergleichbare Möglichkeit, ein Datum in Java zu analysieren, wie z. B. Python-Dateutil? Fehler sind mir egal, ich möchte nur, dass sie größtenteils perfekt sind.

Ihre beste Wette ist es, wirklich um Hilfe zu bitten, um eine Regex zu erstellen, die dem Datumsformatmuster entspricht, und / oder um Brute Forcing durchzuführen.

Vor einigen Jahren schrieb ich eine kleine dumme DateUtilKlasse, die den Job machte. Hier ist ein relevanter Auszug:

private static final Map<String, String> DATE_FORMAT_REGEXPS = new HashMap<String, String>() {{
    put("^\\d{8}$", "yyyyMMdd");
    put("^\\d{1,2}-\\d{1,2}-\\d{4}$", "dd-MM-yyyy");
    put("^\\d{4}-\\d{1,2}-\\d{1,2}$", "yyyy-MM-dd");
    put("^\\d{1,2}/\\d{1,2}/\\d{4}$", "MM/dd/yyyy");
    put("^\\d{4}/\\d{1,2}/\\d{1,2}$", "yyyy/MM/dd");
    put("^\\d{1,2}\\s[a-z]{3}\\s\\d{4}$", "dd MMM yyyy");
    put("^\\d{1,2}\\s[a-z]{4,}\\s\\d{4}$", "dd MMMM yyyy");
    put("^\\d{12}$", "yyyyMMddHHmm");
    put("^\\d{8}\\s\\d{4}$", "yyyyMMdd HHmm");
    put("^\\d{1,2}-\\d{1,2}-\\d{4}\\s\\d{1,2}:\\d{2}$", "dd-MM-yyyy HH:mm");
    put("^\\d{4}-\\d{1,2}-\\d{1,2}\\s\\d{1,2}:\\d{2}$", "yyyy-MM-dd HH:mm");
    put("^\\d{1,2}/\\d{1,2}/\\d{4}\\s\\d{1,2}:\\d{2}$", "MM/dd/yyyy HH:mm");
    put("^\\d{4}/\\d{1,2}/\\d{1,2}\\s\\d{1,2}:\\d{2}$", "yyyy/MM/dd HH:mm");
    put("^\\d{1,2}\\s[a-z]{3}\\s\\d{4}\\s\\d{1,2}:\\d{2}$", "dd MMM yyyy HH:mm");
    put("^\\d{1,2}\\s[a-z]{4,}\\s\\d{4}\\s\\d{1,2}:\\d{2}$", "dd MMMM yyyy HH:mm");
    put("^\\d{14}$", "yyyyMMddHHmmss");
    put("^\\d{8}\\s\\d{6}$", "yyyyMMdd HHmmss");
    put("^\\d{1,2}-\\d{1,2}-\\d{4}\\s\\d{1,2}:\\d{2}:\\d{2}$", "dd-MM-yyyy HH:mm:ss");
    put("^\\d{4}-\\d{1,2}-\\d{1,2}\\s\\d{1,2}:\\d{2}:\\d{2}$", "yyyy-MM-dd HH:mm:ss");
    put("^\\d{1,2}/\\d{1,2}/\\d{4}\\s\\d{1,2}:\\d{2}:\\d{2}$", "MM/dd/yyyy HH:mm:ss");
    put("^\\d{4}/\\d{1,2}/\\d{1,2}\\s\\d{1,2}:\\d{2}:\\d{2}$", "yyyy/MM/dd HH:mm:ss");
    put("^\\d{1,2}\\s[a-z]{3}\\s\\d{4}\\s\\d{1,2}:\\d{2}:\\d{2}$", "dd MMM yyyy HH:mm:ss");
    put("^\\d{1,2}\\s[a-z]{4,}\\s\\d{4}\\s\\d{1,2}:\\d{2}:\\d{2}$", "dd MMMM yyyy HH:mm:ss");
}};

/**
 * Determine SimpleDateFormat pattern matching with the given date string. Returns null if
 * format is unknown. You can simply extend DateUtil with more formats if needed.
 * @param dateString The date string to determine the SimpleDateFormat pattern for.
 * @return The matching SimpleDateFormat pattern, or null if format is unknown.
 * @see SimpleDateFormat
 */
public static String determineDateFormat(String dateString) {
    for (String regexp : DATE_FORMAT_REGEXPS.keySet()) {
        if (dateString.toLowerCase().matches(regexp)) {
            return DATE_FORMAT_REGEXPS.get(regexp);
        }
    }
    return null; // Unknown format.
}

(Husten, Initialisierung der doppelten Zahnspange, Husten, es war nur, um alles in eine maximale Länge von 100 Zeichen zu bringen;))

Sie können es ganz einfach selbst mit neuen Regex- und Datumsformatmustern erweitern.

Es gibt eine schöne Bibliothek namens Natty, die meiner Meinung nach zu Ihren Zwecken passt:

Natty ist ein in Java geschriebener Datums-Parser in natürlicher Sprache. Bei einem Datumsausdruck wendet natty Standardtechniken zur Spracherkennung und -übersetzung an, um eine Liste der entsprechenden Datumsangaben mit optionalen Analyse- und Syntaxinformationen zu erstellen.

Sie können es auch online ausprobieren !

Was ich gesehen habe, ist eine Date util-Klasse, die mehrere typische Datumsformate enthält. Wenn DateUtil.parse (Datum) aufgerufen wird, versucht es, das Datum mit jedem Datumsformat intern zu analysieren, und löst nur dann Ausnahmen aus, wenn keines der internen Formate es analysieren kann.

Es ist im Grunde ein Brute-Force-Ansatz für Ihr Problem.

Sie könnten Dateparser versuchen .

Es kann jeden String automatisch erkennen und ihn korrekt und schnell in Date , Calendar , LocalDateTime , OffsetDateTime analysieren ( 1us~1.5us).

Es basiert nicht auf einem natural language analyzeroder SimpleDateFormatoder regex.Pattern.

Damit müssen Sie keine geeigneten Muster wie yyyy-MM-dd'T'HH:mm:ss.SSSZoder vorbereiten yyyy-MM-dd'T'HH:mm:ss.SSSZZ:

Date date = DateParserUtils.parseDate("2015-04-29T10:15:00.500+0000");
Calendar calendar = DateParserUtils.parseCalendar("2015-04-29T10:15:00.500Z");
LocalDateTime dateTime = DateParserUtils.parseDateTime("2015-04-29 10:15:00.500 +00:00");

Alles funktioniert gut, bitte genießen Sie es.

Ich habe keine Ahnung, wie man in Python analysiert. In Java können wir das so machen

SimpleDateFormat sdf1 = new SimpleDateFormat("dd-MM-yyyy");
  java.util.Date normalDate = null;
  java.sql.Date sqlDate = null;
  normalDate = sdf1.parse(date);
  sqlDate = new java.sql.Date(normalDate.getTime());
  System.out.println(sqlDate);

Ich denke, wie Java werden einige vordefinierte Funktionen in Python vorhanden sein. Sie können dieser Methode folgen. Diese Methode analysiert das String-Datum in SQL-Datum (TT-MM-JJJJ).

import java.text.SimpleDateFormat;
import java.text.ParseException;
public class HelloWorld{
     public static void main(String []args){
        String date ="26-12-2019";
         SimpleDateFormat sdf1 = new SimpleDateFormat("dd-MM-yyyy");
        java.util.Date normalDate = null;
        java.sql.Date sqlDate = null;
        if( !date.isEmpty()) {
            try {
                normalDate = sdf1.parse(date);
                sqlDate = new java.sql.Date(normalDate.getTime());
                System.out.println(sqlDate);
            } catch (ParseException e) {
            }
        }
     }
} 

Führen Sie dies aus!

//download library:   org.ocpsoft.prettytime.nlp.PrettyTimeParser
String str = "2020.03.03";
Date date = new PrettyTimeParser().parseSyntax(str).get(0).getDates().get(0);
System.out.println(date)