Heute wollen wir uns noch anschauen, wie man Werte parst, danach sind wir mit dem Kapitel der Klassen endlich durch 
NumberFormat a = NumberFormat.getInstance();
try {
System.out.println(a.parse(“1234,56″)); // Parsen in einen float-Wert; Ausgabe: 1234,56
a.setParseIntegerOnly(true); // Abänderung; Parse soll von diesem Punkt an in int-Werten stattfinden
System.out.println(a.parse(“1234,56″)); // Parsen in einen int-Wert; Ausgabe: 1234
} catch (Exception e){e.printStackTrace(); }
Auch hier möchte ich abschließend einige Methoden dieser Klasse vorstellen. Erst einmal – wie immer – die nötigen Definitionen:
float number = 123.45678f;
NumberFormat a = NumberFormat.getInstance();
Beim Ausdruck des formatierten Wertes eine kleine Überraschung:
System.out.println(a.format(number)); // Ausgabe: 123,457
Das ist erst einmal verwirrend, wir haben doch die Zahl anders definiert. Die Klasse NumberFormat ist aber dermassen mächtig, dass sie die Anzahl der Nachkommastellen vordefiniert. Mit
System.out.println(a.getMaximumFractionDigits());
wird die Anzahl der Nachkommastellen ausgegeben. Die Anzahl der Nachkommastellen kann mit
a.setMaximumFractionDigits(5);
abgeändert werden.
Heute wollen wir uns mit der Formatierung von Zahlen und Währungen befassen. Fangen wir mal mit der Definiton einer entsprechenden Variablen an:
float number = 123.45f;
Locale loc = new Locale(“en”,”US”); // Definition der USA-Localen
NumberFormat a = NumberFormat.getInstance(); // Default-Zahlenformat
a=NumberFormat.getInstance(loc); // Definition des USA-Zahlenformates
System.out.println(a.format(number)); // Ausgabe: 123.45
a=NumberFormat.getCurrencyInstance(); // Definition der Default-Währung
System.out.println(a.format(number)); // Ausgabe: 123,45 €
a=NumberFormat.getCurrencyInstance(loc); // Definition der USA-Währung
System.out.println(a.format(number)); // Ausgabe: $123.45
Abschliessend möchte ich noch ein paar Methoden der Klasse java.util.Locale vorstellen.
Gehen wir von unseren bekannten Definitionen aus:
Locale germany = new Locale(“de”, “DE”);
Locale englisch_uk = new Locale (“en”,”UK”);
Locale portugisisch_brasilien = new Locale (“pt”,”BR”);
Hier ein paar Länderbezogene Methoden:
System.out.println(germany.getCountry()); // Ausgabe des Länderkürzels: DE
System.out.println(germany.getDisplayCountry()); //Ausgabe des Landes in der Default-Sprache: Deutschland
System.out.println(germany.getDisplayCountry(portugisisch_brasilien)); // Ausgabe des Landes in der angegebenen Sprache/ portugiesisch: Alemanha
System.out.println(englisch_uk.getLanguage()); // Ausgabe des Sprachkürzels: en
System.out.println(englisch_uk.getDisplayLanguage()); // Ausgabe der Sprache in der default-Sprache deutsch: Englisch
System.out.println(englisch_uk.getDisplayLanguage(portugisisch_brasilien)); // Ausgabe der Sprache in der angegebenen Sprache portugiesisch: inglês
System.out.println(englisch_uk.getDisplayLanguage(englisch_uk)); // Ausgabe der Sprache in der angegebenen Sprache englisch: English
Heute möchte ich ein paar Tücken der Locale-Klasse erläutern.
Fangen wir mit der Definition einer chinesischen Locale an:
Date datum = new Date (123456789L);
Locale chinesisch = new Locale(“zh”,”CN”);
DateFormat df_china = DateFormat.getDateInstance(DateFormat.FULL,chinesisch);
System.out.println(df_china.format(datum));
Alles wird einwandfrei compiliert und ausgeführt, nur der Output ist etwas gewöhnungsbedürftig: 1970?1?2? ???
Dies daran, dass zwar die Klasse java.util.Locale diese Funktionen zur Verfügung stellt, unser System aber diese Zeichen nicht kennt.
Zusätzlich ist zu beachten, dass eine einmal festgesetzte Locale eines DateFormat nicht mehr geändert werden kann. Es existiert einfach keine Methode hierfür… also aufgepasst, falls im SCJP solche Fragen auftauchen
Mit dieser Klasse können Länder- und sprachspezifische Einstellungen vorgenommen werden.
Hier ein paar Beispiele:
Locale germany = new Locale(“de”, “DE”);
Locale englisch_uk = new Locale (“en”,”UK”);
Locale portugisisch_brasilien = new Locale (“pt”,”BR”);
als erstes wird die Sprache definiert, in unseren Beispielen deutsch, englisch und portugiesisch. Die zweite Variable sagt aus, auf welches Land sich diese Sprache bezieht, also deutsch in Deutschland, englisch in England und portugiesisch in Brasilien.
Diese Einstellungen müssen jetzt im DateFormat eingebettet werden, um diese Einstellungen vornehmen zu können:
DateFormat df_deutsch = DateFormat.getDateInstance(DateFormat.FULL,germany);
DateFormat df_uk = DateFormat.getDateInstance(DateFormat.FULL, englisch_uk);
DateFormat df_brasilien =DateFormat.getDateInstance(DateFormat.FULL,portugisisch_brasilien);
Es wird also nur noch das erzeugte Objekt bei der Erzeugung des DateFormat-Objektes hinzugefügt. Alles weitere wie gehabt:
Date datum = new Date (123456789L);
System.out.println(df_deutsch.format(datum)); //Deutsches Format: Freitag, 2. Januar 1970
System.out.println(df_uk.format(datum)); // Englisch-Großbritannien Format: Friday, January 2, 1970
System.out.println(df_brasilien.format(datum)); // Brasilianisch-portugisisches Format: Sexta-feira, 2 de Janeiro de 1970
Heute geht es um die (Rück-)Umwandlung eines Datums in einen String:
Date datum = new Date(123456789L);
DateFormat a = DateFormat.getDateInstance(DateFormat.SHORT);
System.out.println(a.format(datum)); // Ausgabe: 02.01.70 11:17
String string = a.format(datum); // Umwandlung in einen String
System.out.println(string); // Ausgabe gleich der formatierten Ausgabe: 02.01.70 11:17
Date neues_datum = new Date();
try {
neues_datum = a.parse(string); // Zurückparsen des Strings in ein Datum
System.out.println(neues_datum.toString()); // Ausgabe des Datums: Fri Jan 02 00:00:00 CET 1970
} catch (Exception e) { e.printStackTrace(); }
Bitte beim Rückparsen (bzw bei Fragen zu solchen) genau aufpassen; da ja die Zeit nicht dem String übergeben wurde, kann diese auch nicht in das Datum zurückgeparst werden. Es wird also die default-Zeitangabe 00:00:00 gespeichert.
Heute wollen wir uns die Befehle zur Datumsformatierung anschauen:
Date datum = new Date(123456789L); // Anlage des zu formatierendenden Datums
DateFormat a = DateFormat.getInstance(); // Anlage eines Format-Objektes
System.out.println(datum.toString()); // “ursprüngliches” Datumsformat: Fri Jan 02 11:17:36 CET 1970
System.out.println(a.format(datum)); // Urspungsformat: 02.01.70 11:17
DateFormat b = DateFormat.getDateInstance();
System.out.println(b.format(datum)); // Urspungsformat: 02.01.1970
DateFormat c = DateFormat.getDateInstance(DateFormat.SHORT);
System.out.println(c.format(datum)); //Ausgabe: 02.01.70
DateFormat d = DateFormat.getDateInstance(DateFormat.MEDIUM);
System.out.println(d.format(datum)); //Ausgabe: 02.01.1970
DateFormat e = DateFormat.getDateInstance(DateFormat.LONG);
System.out.println(e.format(datum)); //Ausgabe: 02. Januar 1970
DateFormat f = DateFormat.getDateInstance(DateFormat.FULL);
System.out.println(f.format(datum)); //Freitag, 2. Januar 1970
Wie schon in der Übersicht kurz angesprochen dient java.util.Date als eine Art Brücke zu Calendar. Dies schauen wir uns heute genauer an:
Calendar Kalender = Calendar.getInstance(); // Anlage eines Objektes vom Typ Calendar
Date datum = new Date(123456789L); // Anlage eines Objektes vom Typ Datum
System.out.println(datum.toString()); // Ausgabe des Datums, hier: Fri Jan 02 11:17:36 CET 1970
Bis hierhin also nichts neues. Nun wollen wir uns mal die Zusammenarbeit beider Klassen anschauen:
Kalender.setTime(datum); // Übergabe des Wertes an Calendar
Kalender.add(Calendar.HOUR, + 20); // Calendar fügt 20 Stunden dem Datum hinzu
datum=Kalender.getTime(); // … und übergibt den Wert zurück an das Objekt datum
System.out.println(datum.toString()); // Ausgabe: Sat Jan 03 07:17:36 CET 1970
Wir können aber auch mit dieser Funktion 20 Stunden hinzuzählen ohne dass andere Werte des Objektes berücksichtigt werden:
Kalender.roll(Calendar.HOUR, +20);// Hinzufügen von 20 Stunden
datum=Kalender.getTime(); // Übergabe an Datum
System.out.println(datum.toString()); //Ausgabe: Sat Jan 03 07:17:36 CET 1970
System.out.println(Kalender.getTime()); // gleiche Ausgabe, es muss also nicht zwingend an Date zurückgegeben werden
Heute wollen wir uns die java.util.Calendar-Funktionen genauer anschauen:
Calendar Kalender = Calendar.getInstance(); //Anlage eines Standard-Kalenders
System.out.println(Kalender.getTime()); // Ausgabe der Zeit, hier: Mon Apr 11 08:28:58 CEST 2011
es können aber auch kompliziertere Werte abgefragt werden, z.B.
System.out.println(Kalender.get(Calendar.WEEK_OF_YEAR)); // Ausgabe der Jahreswoche, hier: 15
System.out.println(Kalender.get(Calendar.DAY_OF_YEAR)); // Ausgabe der Anzahl Tage in diesem Jahr bis zum gespeicherten Datum, hier: 101
Bitte beachtet, dass Calendar abstrakt ist und deswegen Calendar c = new Calendar(); zu einem Compilerfehler führt.
