Apps für Android programmieren leicht gemacht!
DateTime in Unix parsen

DateTime in Unix parsen

Vor Kurzem habe ich einen Artikel zum Thema Daten von PHP Server erhalten geschrieben.
Aufbauend auf diesem Artikel kam die Frage auf, wie man das von PHP übergebene Datum in Java behandeln kann.

Wenn wir uns diesen Artikel noch einmal genauer anschauen, dann können wir sehen, dass wir in der MySQL Datenbank den Datentyp DateTime angegeben haben.
Dieser wird uns in PHP ein Datum in etwa diesem Format ausgeben: „2016-05-15 12:50:23“. Es handelt sich also um das Datum vom 15.5.2016 und die Uhrzeit 12:50 und 23 Sekunden.
Um unter Android besser mit einem Datum umgehen können sollten wir versuchen dieses in einem String hardcodierte Datum in ein Unix Zeit umzuwandeln.

Bei Unix Zeit handelt es sich um die Zeit in Sekunden seit dem 1.1.1970 um 0:00 Uhr

Wir können nun auf mehrere verschiedene Weisen versuchen diesen String in eine Sekundenzeit umzuwandeln.
Ich habe mich aus Lernzwecken dafür entschieden die Zeit nicht mittels einer vorgefertigten Methode zu verarbeiten, sondern verständlich in Einzelschritten.
Zusätzlich gibt es natürlich noch eine vorgefertigte Funktion, von Android, die ich hier ansprechen werde. (Ganz unten zu finden.)

 

Einzelne Zahlen auslesen:

Bevor wir beginnen können eine Unix Zeit zu errechnen ist es dringend erforderlich den String in Integer (Zahlen) umzuwandeln, denn mit einem String können wir nicht rechnen, zumal in diesem String Sonderzeichen enthalten sind.

Wir können uns eine Funktion namens .split() zu nutze machen.
Dieser Funktion wird ein Trennzeichen übergeben und sie splittet den String an diesem Trennzeichen auf.
Als Ergebnis von .split() erhalten wir ein Array.

Vorerst sollten wir versuchen das Datum von der Uhrzeit zu trennen. Also geben wir als erstes Trennzeichen das Leerzeichen an.
Als Ergebnis erhalten wir ein Array mit 2 Einträgen (1. Eintrag = Datum, 2. Eintrag = Uhrzeit), auf die wir jeweils wieder .split() anwenden können, um Jahr, Monat und Tag zu trennen. Das selbe machen wir mit den Stunden, Minuten und Sekunden.

Schema - DateTime in Unix parsen
Hier einmal die Vorgehensweise schematisch aufgezeichnet. (Klicken zum Vergrößern)

 

// Unsere Ausgangslage
String datetime = "2016-05-15 12:50:23";

// Trennen von Datum und Uhrzeit
String[] getrennt = datetime.split(" ");

// Trennen von Jahr, Monat und Tag
String[] datum = getrennt[0].split("-");

// Trennen von Stunde, Minute und Sekunde
String[] uhrzeit = getrennt[1].split(":");

Na dass hat ja schon einmal super geklappt.
Wir haben die einzelnen Zahlen zwar jetzt getrennt, aber damit arbeiten können wir immer noch nicht richtig. Da wir nur mit Zahlen und nicht mit Strings rechnen können.
Wandeln wir die beiden Arrays von Strings nun in Zahlen um und schreiben sie in Variablen, mit sinnvollen Namen.

// Die ausgesplitteten Strings in Zahlen umwandeln und in sinnvolle variablen schreiben
int jahr = Integer.parseInt(datum[0]);
int monat = Integer.parseInt(datum[1]);
int tag = Integer.parseInt(datum[2]);
int stunden = Integer.parseInt(uhrzeit[0]);
int minuten = Integer.parseInt(uhrzeit[1]);
int sekunden = Integer.parseInt(uhrzeit[2]);

 

 

UNIX errechnen:

So, wir haben alle nötigen Variablen zusammengesammelt und können nun rechnen.
Wir sollten uns eine Variable Unix erstellen, zu der wir jeweils die Sekunden addieren. Beim Jahr selber müssen wir allerdings aufpassen, dass wir von unserem momentanen Jahr die 1970 für das Startjahr der Unixzeit subtrahieren. Zu beachten ist, dass wir bei den Monaten nun vor einem Problem stehen. Einige Monate haben 30 Tage, andere 31 Tage. Der Februar besitzt lediglich 28 Tage. In Schaltjahren hat der Februar dafür 29 Tage, wie also berechnen wir dies nun?

  • 1 Sekunde = 1 Sekunde
  • 1 Minute = 60 Sekunden
  • 1 Stunde = 3600 Sekunden
  • 1 Tag = 86400 Sekunden
  • 1 Monat = 2419200 (28 Tage) oder 2505600 (29 Tage) oder 2592000 (30 Tage) oder 2678400 (31 Tage)

Das klingt jetzt alles etwas komplizierter, als es eigentlich ist. Jeder Monat, abgesehen vom Februar, hat eine feste Anzahl an Tagen. Für die Schaltjahre rechnen wir für den Februar 29 Tage in Sekunden auf, ansonsten 28 Tage in Sekunden.

Wir gehen nun also per Schleife alle abgeschlossenen Jahre durch und errechnen, ob es sich um ein Schaltjahr handelte:

// Alle bereits abgeschlossenen Jahre seit dem 1.1.1970 durchlaufen
for(int i = 1970; i < jahr; i++){
  unix += 2678400 * 7; // 7 Monate mit 31 Tagen.
  unix += 2592000 * 4; // 4 Monate mit 30 Tagen.

  // 28 oder 29 Tage für den Februar aufrechnen.
  if(i % 4 == 0 && (i % 100 != 0 || i % 400 == 0)){
    unix += 2505600; // 29 Tage aufrechnen.
  }else{
    unix += 2419200; // 28 Tage aufrechnen.
  }
}

Nun gehen wir durch alle bereits abgeschlossenen Monate und anschließend rechnen wir die Tage, Stunden, Minuten und Sekunden dieses laufenden Monats auf.

// Alle bereits abgeschlossenen Monate für dieses Jahr berechnen
for(int j = monat-1; j > 0; j--){

  // Januar, März, Mai, Juli, August, Oktober, Dezember haben alle 31 Tage
  if(j == 1 || j == 3 ||  j == 5 ||  j == 7 ||  j == 8 ||  j == 0 ||  j == 12){
    unix += 2678400;
  }

  // April, Juni, Sptember, November haben alle 30 Tage
  if(j == 4 || j == 6 || j == 9 || j == 11){
    unix += 2592000;
  }

  // Für den Februar wieder auf ein Schaltjahr prüfen
  if(j == 2){
    // 28 oder 29 Tage für den Februar aufrechnen.
    if(jahr % 4 == 0 && (jahr % 100 != 0 || jahr % 400 == 0)){
      unix += 2505600; // 29 Tage aufrechnen.
    }else{
      unix += 2419200; // 28 Tage aufrechnen.
    }
  }
}

// Alle Sekunden, Minuten, Stunden und Tage aufrechnen
unix += sekunden;
unix += (minuten * 60);
unix += (stunden * 3600);
unix += (tag - 1) * 86400;

 

 

UNIX ausgeben lassen:

Für die Faulen unter euch gibt es selbstverständlich auch eine vorgefertigte Funktion, der wir die eben ausgelesenen Daten einfach nur übergeben können und die uns die UNIX Zeit ohne große Überlegungen ausgibt.

Nach den Imports von:

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

Kann man ganz einfach folgende Funktion nutzen:

String str_date="2016-05-15 12:50:23";
DateFormat formatter ;
Date date = null;
formatter = new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
try {
    date = formatter.parse(str_date);
} catch (ParseException e) {
    e.printStackTrace();
}

System.out.println("Heute ist die Unix Zeit von " + date.getTime() + " in Millisekunden.");

 

Marvin

Ich bin 23 Jahre jung und studiere zurzeit Wirtschaftsinformatik an der Georg-August-Universität in Göttingen. Ich bin ein Mensch, der sich neben der Programmierung noch für tausend andere Dinge interessiert, die mal mehr und mal weniger verrückt sind. Vor allem aber bin ich Feuer und Flamme mit der Programmierung von eigenen kleinen Apps und Programmen, die mein Leben bereichern.

Kommentar hinzufügen

*Pflichtfeld