alle möglichen Datumseingaben im Textfeld abfangen

[Cheefrocker123]

Hallo zusammen,

wisst wir eine Saubere Lösung wie man alle Datumseingaben verwenden kann und in der Form TT.MM.JJJJ ausgibt:

Mögliche Eingaben sind:

TTMMJJ
TTMMJJJJ
T.M.JJJJ
T.M.JJ
TT.MM.JJ
TT.MM.JJJJ

Hab zwar eine Art Parser geschrieben und ermittle alles in String aber kann ich das nicht Java-Boardmitteln(Pattern) komfortabel umsetzen??


finde solche Lösungen bissel blöd:

// TTMMJJ
                    if ((Integer.parseInt(Datum.substring(0, 2)) >= 0) &&
                            (Integer.parseInt(Datum.substring(0, 2)) <= 31) &&
                            (Integer.parseInt(Datum.substring(2, 4)) >= 0) &&
                            (Integer.parseInt(Datum.substring(2, 4)) <= 12)) {
                        Tag = Datum.substring(0, 2);
                        Monat = Datum.substring(2, 4);
                        Jahr = Datum.substring(4, 6);

 

[SlaterB]

anhand der String-Länge und der Indexe der Punkte kannst du das Format eindeutig bestimmen (ansonsten ginge es eh nicht),
also mache das und verwende dann das richtige SimpleDateFormat für alle 6 Fälle

 

[Einwegdose]

Um das aufzugreifen, mit Pattern sollte es auch möglich sein.

Hier eine nicht-logische Prüfung für den letzten Fall:

	Pattern p = Pattern.compile("\\d{1,2}\\.\\d{1,2}\\.\\d{4}");
	Matcher m = p.matcher(check);
	if (m.matches()) {
	    System.out.println("RICHTIG");
	}

 

[SlaterB]

es sind aber auch Eingaben ganz ohne Punkt erlaubt

außerdem würde dieser Check auch 1.11.2007 erlauben, was nicht ok ist
oder verstehe ich T.M.JJ falsch? wie soll man da eigentlich Tage oder Monate > 9 darstellen?

 

[Guest]

außerdem würde dieser Check auch 1.11.2007 erlauben, was nicht ok ist
oder verstehe ich T.M.JJ falsch? wie soll man da eigentlich Tage oder Monate > 9 darstellen?

T.M.JJ heißt nicht, dass Montage / Tage > 9 nicht erlaubt sind, sondern es heißt nur, dass Tage / Monate < 10 OHNE führende Nullen genommen werden.

1.1.08

oder eben

1.11.08

 

[Escorter]

T.M.JJ würde ich so verstehen, dass es bei Zahlen <10 keine Führende-Null gibt.

 

[SlaterB]

ok, da lerne ich dann auch noch mal was zu SimpleDateFormat

da die führende 0 im anderen Format erlaubt ist ist das ja kein Problem,
das Checken der Länge + Punkt-Indexe wäre noch denkbar

 

[Einwegdose]

Um eine weitere Prüfung wirst du wohl nicht drumherum kommen ... hier mal ein VERSUCH eines logischen Patterns für die letzte Möglichkeit (bitte nicht hauen, habe erst gestern Patterns für mich entdeckt ^^):

Pattern p = Pattern.compile("[1-3]\\d{1}\\.[0-1]\\d{1}\\.[1-2]\\d{3}");

Und ja, ich weiss das damit auch der 39.03.1234 akzeptiert wird (wobei die Jahreszahlen noch weiter spezifiziert werden könnten)

 

[Gast]

Hier meine Klasse. Könnte ihr mich bitte verbessern. Wer lust kann kann eine Schnellere bzw saubere Lösung zeigen.

import java.util.*;


public class Datumseingaben {
    //  Datum Rückwärts einlesen
    public String Datum_RW(String Datum) {
        String AusgabeString = "";

        // Wenn weniger als 8 Zeichen dann ist es kein Datum -> String "" ausgeben
        if (Datum.length() == 8) {
            AusgabeString = Datum.substring(6, 8) + "." +
                Datum.substring(4, 6) + "." + Datum.substring(0, 4);
        } else {
            AusgabeString = "";
        }

        return (AusgabeString);
    }

    // formatiert Datum vorwärts
    public String Datums_VW(String Datum) throws Exception {
        boolean Zahl = true;
        String TDatum = "";

        for (int i = 0; i <= (Datum.length() - 1); i++) {
            if ((Datum.charAt(i) == '1') || (Datum.charAt(i) == '2') ||
                    (Datum.charAt(i) == '3') || (Datum.charAt(i) == '4') ||
                    (Datum.charAt(i) == '5') || (Datum.charAt(i) == '6') ||
                    (Datum.charAt(i) == '7') || (Datum.charAt(i) == '8') ||
                    (Datum.charAt(i) == '9') || (Datum.charAt(i) == '0') ||
                    (Datum.charAt(i) == '.')) {
                Zahl = true;
            } else {
                Zahl = false;

                break;
            }
        } // for

        if (Zahl == true) {
            // Variablen deklarieren und initialisieren
            String Tag = "";
            String Monat = "";
            String Jahr = "";

            // Wird benötigt für Addiere_punkt als zwischenspeicher
            String Addiere_Token = "";
            String Datum_neu = "";
            int hilfe = 0;
            int ErstePunktPos = 0;
            boolean punkt = false;
            StringTokenizer Addiere_punkt = new StringTokenizer(Datum, ".");

            //          Überprüft ob punkte vorhanden sind wenn ja dann berücksichtigt er diesen
            for (int i = 0; i < (Datum.length() - 1); i++) {
                if (Datum.charAt(i) == '.') {
                    punkt = true;
                    ErstePunktPos = i;

                    break;
                }
            } // end for

            // Wenn ein Punkt im Datum ist wird er wie folgt berechnet:
            if (punkt == true) {
                // zerlegt Datum in Seine Bestandteile z.b. aus 12.12.99 wird Tag = 12 Monat = 12 und Jahr =99 gemacht
                while (Addiere_punkt.hasMoreTokens()) {
                    Addiere_Token = Addiere_punkt.nextToken();
                    hilfe++;

                    if (hilfe == 1) {
                        Tag = Addiere_Token;
                    } else if (hilfe == 2) {
                        Monat = Addiere_Token;
                    } else if (hilfe == 3) {
                        Jahr = Addiere_Token;
                    }
                } // end while

                // Addiert Datumswerte zu einem neuen Wert, dadurch kann der Algorithmus sowohl
                // für das Datum ohne Punkt und das Datum mit dem Punkt gleich genutzt werden
                Datum_neu = Tag + Monat + Jahr;

                if (Datum_neu.length() == 4) {
                    // TMJJ = 4 Zeichen
                    Tag = "0" + Datum_neu.substring(0, 1);
                    Monat = "0" + Datum_neu.substring(1, 2);
                    Jahr = Datum_neu.substring(2, 4);

                    // Hier muss unterschieden werden, ob es das 19te oder 20te Jahrhundert ist
                    if ((Integer.parseInt(Jahr) >= 0) &&
                            (Integer.parseInt(Jahr) <= 55)) {
                        Jahr = "20" + Jahr;
                    } else if ((Integer.parseInt(Jahr) >= 56) &&
                            (Integer.parseInt(Jahr) <= 99)) {
                        Jahr = "19" + Jahr;
                    }

                    // ----------------------------------------------------------------------------
                } else if (Datum_neu.length() == 5) {
                    // TMMJJ
                    if (ErstePunktPos == 1) {
                        Tag = "0" + Datum_neu.substring(0, 1);
                        Monat = Datum_neu.substring(1, 3);
                        Jahr = Datum_neu.substring(3, 5);
                    } // TTMJJ
                    else {
                        Tag = Datum_neu.substring(0, 2);
                        Monat = "0" + Datum_neu.substring(2, 3);
                        Jahr = Datum_neu.substring(3, 5);
                    }

                    // Hier muss unterschieden werden, ob es das 19te oder 20te Jahrhundert ist
                    if ((Integer.parseInt(Jahr) >= 0) &&
                            (Integer.parseInt(Jahr) <= 55)) {
                        Jahr = "20" + Jahr;
                    } else if ((Integer.parseInt(Jahr) >= 56) &&
                            (Integer.parseInt(Jahr) <= 99)) {
                        Jahr = "19" + Jahr;
                    }
                } else if (Datum_neu.length() == 7) {
                    // TMMJJJJJ
                    if (ErstePunktPos == 1) {
                        Tag = "0" + Datum_neu.substring(0, 1);
                        Monat = Datum_neu.substring(1, 3);
                        Jahr = Datum_neu.substring(3, 7);
                    } // TTMJJJJ
                    else {
                        Tag = Datum_neu.substring(0, 2);
                        Monat = "0" + Datum_neu.substring(2, 3);
                        Jahr = Datum_neu.substring(3, 7);
                    }
                } else if (Datum_neu.length() == 8) {
                    //                  TTMMJJJJ = 8 Zeichen
                    Tag = Datum_neu.substring(0, 2);
                    Monat = Datum_neu.substring(2, 4);
                    Jahr = Datum_neu.substring(4, 8);
                } else if (Datum_neu.length() == 6) {
                    // TMJJJJ = 6 Zeichen oda TTMMJJ = 6 Zeichen!!!!!!!!!!! Deshalb muss überprüft werden
                    // TTMMJJ
                    if ((Integer.parseInt(Datum_neu.substring(0, 2)) >= 0) &&
                            (Integer.parseInt(Datum_neu.substring(0, 2)) <= 31) &&
                            (Integer.parseInt(Datum_neu.substring(2, 4)) >= 0) &&
                            (Integer.parseInt(Datum_neu.substring(2, 4)) <= 12)) {
                        Tag = Datum_neu.substring(0, 2);
                        Monat = Datum_neu.substring(2, 4);
                        Jahr = Datum_neu.substring(4, 6);

                        if ((Integer.parseInt(Jahr) >= 0) &&
                                (Integer.parseInt(Jahr) <= 55)) {
                            Jahr = "20" + Jahr;
                        } else if ((Integer.parseInt(Jahr) >= 56) &&
                                (Integer.parseInt(Jahr) <= 99)) {
                            Jahr = "19" + Jahr;
                        }
                    } // if((Integer.parseInt(Datum.substring(0,2))>=0)&&(Integer.parseInt(Datum.substring(0,2))<=31)

                    // &&(Integer.parseInt(Datum.substring(0,2))>=0)&&(Integer.parseInt(Datum.substring(0,2))<=12))
                    else if ((Integer.parseInt(Datum_neu.substring(2, 4)) == 19) ||
                            (Integer.parseInt(Datum_neu.substring(2, 4)) == 20)) {
                        Tag = "0" + Datum_neu.substring(0, 1);
                        Monat = "0" + Datum_neu.substring(1, 2);
                        Jahr = Datum_neu.substring(2, 6);
                    } // End else
                } // ende punkt
            } else // Hier kommt der Teil ohne den Punkt
             {
                if (Datum.length() == 4) {
                    // TMJJ = 4 Zeichen
                    Tag = "0" + Datum.substring(0, 1);
                    Monat = "0" + Datum.substring(1, 2);
                    Jahr = Datum.substring(2, 4);

                    // Hier muss unterschieden werden, ob es das 19te oder 20te Jahrhundert ist
                    if ((Integer.parseInt(Jahr) >= 0) &&
                            (Integer.parseInt(Jahr) <= 55)) {
                        Jahr = "20" + Jahr;
                    } else if ((Integer.parseInt(Jahr) >= 56) &&
                            (Integer.parseInt(Jahr) <= 99)) {
                        Jahr = "19" + Jahr;
                    }

                    // ----------------------------------------------------------------------------
                } else if (Datum.length() == 5) {
                    Tag = "0" + Datum.substring(0, 1);
                    Monat = Datum.substring(1, 3);
                    Jahr = Datum.substring(3, 5);

                    // Hier muss unterschieden werden, ob es das 19te oder 20te Jahrhundert ist
                    if ((Integer.parseInt(Jahr) >= 0) &&
                            (Integer.parseInt(Jahr) <= 55)) {
                        Jahr = "20" + Jahr;
                    } else if ((Integer.parseInt(Jahr) >= 56) &&
                            (Integer.parseInt(Jahr) <= 99)) {
                        Jahr = "19" + Jahr;
                    }
                } else if (Datum.length() == 7) {
                    // TMMJJJJJ
                    if (ErstePunktPos == 1) {
                        Tag = "0" + Datum.substring(0, 1);
                        Monat = Datum.substring(1, 3);
                        Jahr = Datum.substring(3, 7);
                    } // TTMJJJJ
                    else {
                        Tag = Datum.substring(0, 2);
                        Monat = "0" + Datum.substring(2, 3);
                        Jahr = Datum.substring(3, 7);
                    }
                } else if (Datum.length() == 8) {
                    //                  TTMMJJJJ = 8 Zeichen
                    Tag = Datum.substring(0, 2);
                    Monat = Datum.substring(2, 4);
                    Jahr = Datum.substring(4, 8);
                } else if (Datum.length() == 6) {
                    // TMJJJJ = 6 Zeichen oda TTMMJJ = 6 Zeichen!!!!!!!!!!! Deshalb muss überprüft werden
                    // TTMMJJ
                    if ((Integer.parseInt(Datum.substring(0, 2)) >= 0) &&
                            (Integer.parseInt(Datum.substring(0, 2)) <= 31) &&
                            (Integer.parseInt(Datum.substring(2, 4)) >= 0) &&
                            (Integer.parseInt(Datum.substring(2, 4)) <= 12)) {
                        Tag = Datum.substring(0, 2);
                        Monat = Datum.substring(2, 4);
                        Jahr = Datum.substring(4, 6);

                        if ((Integer.parseInt(Jahr) >= 0) &&
                                (Integer.parseInt(Jahr) <= 55)) {
                            Jahr = "20" + Jahr;
                        } else if ((Integer.parseInt(Jahr) >= 56) &&
                                (Integer.parseInt(Jahr) <= 99)) {
                            Jahr = "19" + Jahr;
                        }
                    } // if((Integer.parseInt(Datum.substring(0,2))>=0)&&(Integer.parseInt(Datum.substring(0,2))<=31)

                    // &&(Integer.parseInt(Datum.substring(0,2))>=0)&&(Integer.parseInt(Datum.substring(0,2))<=12))
                    else if ((Integer.parseInt(Datum.substring(2, 4)) == 19) ||
                            (Integer.parseInt(Datum.substring(2, 4)) == 20)) {
                        Tag = "0" + Datum.substring(0, 1);
                        Monat = "0" + Datum.substring(1, 2);
                        Jahr = Datum.substring(2, 6);
                    } // End else
                } // ende punkt
            }

            int j = Integer.parseInt(Jahr);
            int m = Integer.parseInt(Monat);
            int t = Integer.parseInt(Tag);

            // Teste das Datum auf Richtigkeit sonst gibt es das Datum nicht!
            GregorianCalendar TTDatum = new GregorianCalendar(j, (m - 1), t);

            if ((TTDatum.get(Calendar.YEAR) == j) &&
                    (TTDatum.get(Calendar.MONTH) == (m - 1)) &&
                    (TTDatum.get(Calendar.DATE) == t)) {
                return (Tag + "." + Monat + "." + Jahr);
            } else {
                return ("");
            }

            // ---------------------------------------------------------------------------
        } // zahl
        else {
            return ("");
        }
    } // public Datums_Formatierung(String Datum) {

    public int get_jahr(String Datum) throws Exception{
        int Jahr = 0;
        try
        {
        Jahr = Integer.parseInt(Datum.substring(6, 10));
        }catch(Exception e)
        {
           throw new Exception(e);
        }
        return (Jahr);
    }

    public int get_monat(String Datum)throws Exception {
        
        int Jahr = 0;
        
        try
        {
            Jahr  = Integer.parseInt(Datum.substring(3, 5));
        }catch(Exception e)
        {
            throw new Exception(e);
       
        } 
        return (Jahr);
    
    
    }

    public int get_tag(String Datum)throws Exception  {
        int Jahr = 0;
        
        try
        {
        Integer.parseInt(Datum.substring(0, 2));
        }catch(Exception e)
        {
            throw new Exception(e); 
        }
        return (Jahr);
    }
} // public class Datums_Formatierung

 

[Guest]

T.M.JJ würde ich so verstehen, dass es bei Zahlen <10 keine Führende-Null gibt.

Richtig mein Freund!!

 

[SlaterB]

wie gesagt, etwas sauberer wäre:

SimpleDateFormat 1-6 definieren

länge bestimmen
index1, index2 bestimmen (-1 für Punkt nicht vorhanden)

und dann ein
if-else-Konstrukt a la

if (index1 < 2) {
   // kann nur T.M.JJJJ oder T.M.JJ sein
   if (laenge >= 8) {
      // T.M.JJJJ -SimpleDateFormat
   } else {
     // T.M.JJ -SimpleDateFormat
   }
} else {
// usw.

}

drumherum noch ParseExpetion abfangen -> falsches Format

damit bekämst du ein Date-Objekt, mit Calendar kannst du dann Tag und Jahr usw. rausholen, falls gewünscht

 

[Gast]

Vielen dank @SlaterB

 

[SlaterB]

index des zweiten Punktes braucht man nicht mal,
wenn ich aber noch deinen Code wie

// Hier muss unterschieden werden, ob es das 19te oder 20te Jahrhundert ist
if ((Integer.parseInt(Jahr) >= 0) &&
(Integer.parseInt(Jahr) <= 55)) {
Jahr = "20" + Jahr;
} else if ((Integer.parseInt(Jahr) >= 56) &&
(Integer.parseInt(Jahr) <= 99)) {
Jahr = "19" + Jahr;
}

sehe, das ist in der kürzeren Variante natürlich auch nicht zu vermeiden,
wobei man in solchen Fällen natürlich nur EINMAL parsen sollte, allein schon vom Code her kürzer, aber spart auch Berechnungsaufwand