4.9 Formatieren von Ausgaben

Immer wieder müssen Zahlen, Datumsangaben und Text auf verschiedenste Art und Weise formatiert werden. Zur Formatierung bietet Java zwei Lösungen:

• Seit Java 5 realisieren die format()- und printf()-Funktionen eine Ausgabe, so wie sie unter C mit printf() gesetzt wurde.

• Formatieren über Format-Klassen: Allgemeines Formatierungsverhalten wird in einer abstrakten Klasse Format fixiert; konkrete Unterklassen wie NumberFormat und DateFormat nehmen sich spezielle Datenformate vor.

• • Die Format-Klassen bieten nicht nur landes- bzw. sprachabhängige Ausgaben per format(), sondern auch den umgekehrten Weg, Zeichenketten wieder in die Typen wie double oder Date zu zerlegen. Jede Zeichenkette, die vom Format-Objekt erzeugt wurde, kann auch mit dem Parser wieder eingelesen werden.

4.9.1 Formatieren mit format() aus String

Die Klasse String stellt mit der statischen Funktion format() eine Möglichkeit bereit, Zeichenketten nach einer Vorgabe zu formatieren.

String[] arg = { "Ulli", "Tanja" }; 
String s = String.format( "Hallo %s. Es gab einen Anruf von %s.", arg ); 
System.out.println( s );    // Hallo Ulli. Es gab einen Anruf von Tanja.

Der erste übergebene String nennt sich Format-String. Er enthält neben auszugebenden Zeichen weitere so genannte Format-Spezifizierer, die dem Formatierer darüber Auskunft geben, wie er das Argument formatieren soll. %s steht für eine unformatierte Ausgabe eines Strings.

Variable Argumentlisten und System.out.printf()

Mit der Schreibweise von Java 5 für variable Argumentlisten ist das eigene arg-Feld nicht nötig, sodass sich der Funktionsaufruf vereinfacht zu:

String s = String.format( "Hallo %s. Es gab einen Anruf von %s.", "Ulli", "Tanja" );

Praktischerweise ist das Formatieren und Ausgeben auch zu einer neuen Funktion printf() in den PrintWriter und PrintStream (das System.out-Objekt ist vom Typ PrintStream) gewandert, so dass sich jetzt auch schreiben lässt:

System.out.printf( "Hallo %s. Es gab einen Anruf von %s.", "Ulli", "Tanja" );

Auch bei printf() ist als erstes Argument ein Locale möglich.

final class java.lang.String 
implements CharSequence, Comparable<String>, Serializable

• static String format( String format, Object... args ) Liefert einen formatierten String, der aus dem String und den Argumenten hervorgeht.

• static String format( Locale l, String format, Object... args ) Liefert einen formatierten String, der aus der gewünschten Sprache, dem String und Argumenten hervorgeht.

Intern werkeln java.util.Formatter (keine java.text.Format-Objekte), die sich auch direkt verwenden lassen; dort ist auch die Dokumentation festgemacht.

Format-Spezifizierer

Die Anzahl der Format-Spezifizierer ist so groß und ihre weitere Parametrisierung so vielfältig, dass ein Blick in die API-Dokumentation auf jeden Fall nötig ist.

• %n ergibt das/die Zeichen für den Zeilenvorschub, jeweils bezogen auf die aktuelle Plattform. Die Schreibweise ist einem harten \n vorzuziehen, da dies nicht das Zeilenvorschubzeichen der Plattform sein muss.

• %% liefert das Prozentzeichen selbst, wie auch \\ in einem String den Backslash ausmaskiert.

• %s liefert einen String, wobei null zur Ausgabe »null« führt. %S schreibt die Ausgabe groß.

• %b schreibt ein Boolean, und zwar den Wert »true« oder »false« im Fall des Typs Boolean. Die Ausgabe ist immer »false« bei null und »true« bei anderen Typen wie Integer, String. %B schreibt den String groß.

• %c schreibt ein Zeichen, wobei die Typen Character, Byte und Short erlaubt sind. %C schreibt das Zeichen in Großbuchstaben.

• Für die ganzzahligen numerischen Ausgaben mit %d (Dezimal), %x (Hexadezimal), %o (Oktal) sind Byte, Short, Integer, Long und BigInteger erlaubt – %X schreibt die hexadezimalen Buchstaben groß.

• Bei den Fließkommazahlen mit %f oder %e (%E), %g (%G), %a (%A) sind zusätzlich die Typen Float, Double und BigDecimal zulässig.

• Im Fall von Datumsangaben mit %t bzw. %T sind erlaubt: Long, Calendar und Date. %t benötigt zwingend ein Suffix.

• Den Hash-Code schreibt %h bzw. %H. Beim Wert null ist auch das Ergebnis »null«.

Zusätzliche Flags, etwa für Längenangaben und die Anzahl an Nachkommastellen, sind möglich und werden im folgenden Beispiel gezeigt.

Listing 4.15 PrintfDemo.java

import static java.lang.System.out; 
 
import java.util.Date; 
 
public class PrintfDemo 
{ 
 public static void main( String[] args ) 
 { 
  int i = 123; 
 
  out.printf( "|%d|   |%d|%n" ,     i, -i );   // |123|   |-123| 
  out.printf( "|%5d| |%5d|%n" ,     i, -i );   // |  123| | -123| 
  out.printf( "|%-5d| |%-5d|%n" ,   i, -i );   // |123  | |-123 | 
  out.printf( "|%+-5d| |%+-5d|%n" , i, -i );   // |+123 | |-123 | 
  out.printf( "|%05d| |%05d|%n%n",  i, -i );   // |00123| |-0123| 
 
  out.printf( "|%X| |%x|%n", 0xabc, 0xabc );   // |ABC| |abc| 
  out.printf( "|%08x| |%#x|%n%n", 0xabc, 0xabc ); // |00000abc| |0xabc| 
 
  double d = 12345.678; 
 
  out.printf( "|%f| |%f|%n" ,         d, -d ); // |12345,678000| |-12345,678000| 
  out.printf( "|%.2f| |%.2f|%n" ,     d, -d ); // |12345,68| |-12345,68| 
  out.printf( "|%,10f| |%,10f|%n" ,   d, -d ); // |1234,567800| |-1234,567800| 
  out.printf( "|%10.2f| |%10.2f|%n" , d, -d ); // |  12345,68| | –12345,68| 
  out.printf( "|%010.2f| |%010.2f|%n",d, -d ); // |0012345,68| |-012345,68| 
 
  String s = "Monsterbacke"; 
 
  out.printf( "%n|%s|%n", s );                 // |Monsterbacke| 
  out.printf( "|%20s|%n", s );                 // |        Monsterbacke| 
  out.printf( "|%-20s|%n", s );                // |Monsterbacke        | 
  out.printf( "|%7s|%n", s );                  // |Monsterbacke| 
  out.printf( "|%.7s|%n", s );                 // |Monster| 
  out.printf( "|%20.7s|%n", s );               // |             Monster| 
 
  Date t = new Date(); 
  out.printf( "%tT%n", t );                    // 11:01:39 
  out.printf( "%tD%n", t );                    // 05/23/06 
  out.printf( "%1$te. %1$tb%n", t );           // 23. Mai 
 } 
}

Eine Aufgabe wie »formatiere einen String rechtsbündig« ist mit der Methode format() einfach möglich. Im Fall von Fließkommazahlen werden diese nach dem Modus BigDecimal.ROUND_HALF_UP gerundet, so dass etwa System.out.format("%.1f", 0.45); die Ausgabe 0,5 ergibt.

4.9.2 Die Format-Klassen im Überblick

DateFormat, MessageFormat und NumberFormat erweitern die abstrakte Klasse Format. Die Unterklassen übernehmen die Ein-/Ausgabe für Datumsangaben, für allgemeine Programmmeldungen und für Zahlen.

Das Beispiel in der Tabelle zeigt Anwendungen der Klassen.

Jede dieser Klassen implementiert auf jeden Fall die Methode zur Ausgabe format() und zur Erkennung parseObject().

abstract class java.text.Format 
implements Serializable, Cloneable

• String format( Object obj ) Formatiert das Objekt obj und gibt eine Zeichenkette zurück.

• abstract StringBuffer format( Object obj, StringBuffer toAppendTo, FieldPosition pos ) Formatiert ein Objekt und hängt den Text an den angegebenen StringBuffer an. Kann die Zeichenkette nicht mit format() nach den Regeln des Format-Objekts ausgegeben werden, löst die Methode eine IllegalArgumentException aus. Ist die Formatierungsanweisung falsch, so gibt format() das Unicode-Zeichen \uFFFD zurück.

• Object parseObject( String source ) Analysiert den Text von Anfang an.

• abstract Object parseObject( String source, ParsePosition pos ) Der Text wird ab der Stelle pos umgewandelt. Konnte parseObject() die Zeichenkette nicht zurückübersetzen, so folgt eine ParseException. parseObject(String, Parse-Position) verändert das ParsePosition-Objekt nicht und gibt die null-Referenz zurück.

• Object clone() Gibt eine Kopie zurück.

Die Mehrzahl der Format-Unterklassen implementiert Fabrikfunktionen der Art:

• static XXXFormat getYYYInstance() Für ein Formatierungsobjekt mit den Formatierungsregeln für das voreingestellte Land.

• static XXXFormat getYYYInstance( Locale l ) Für ein Formatierungsobjekt mit den Formatierungsregeln für das angegebene Land. So erlauben die Unterklassen von Format es dem Benutzer auch, weitere Objekte zu erzeugen, die an die speziellen Sprachbesonderheiten der Länder angepasst sind.

4.9.3 Zahlen, Prozente und Währungen mit NumberFormat und DecimalFormat formatieren

NumberFormat widmet sich der Ausgabe von Zahlen. Dabei unterstützt die Klasse mit statischen Fabrikfunktionen – also keinen Konstruktoren – vier Typen von Ausgaben:

abstract class java.text.NumberFormat 
extends Format

• static NumberFormat getNumberInstance() Gewöhnlicher Formatierer für Zahlen.

• static NumberFormat getIntegerInstance() Liefert einen Formatierer, der den Nachkommateil abschneidet und rundet.

• static NumberFormat getPercentInstance() Liefert einen Formatierer, der Fließkommazahlen über die format()-Methode im Bereich von 0 bis 1 annimmt und dann als Prozentzahl formatiert. Nachkommastellen werden abgeschnitten.

• static NumberFormat getCurrencyInstance() Liefert einen Formatierer für Währungen, der ein Währungszeichen zur Ausgabe hinzufügt.

Die genannten vier Methoden gibt es jeweils in der parameterlosen Variante und in der Variante mit einem Locale-Objekt, um etwa das Währungszeichen oder das Kommazeichen anzupassen.

Dezimalzahlformatierung mit DecimalFormat

DecimalFormat ist eine Unterklasse von NumberFormat und ermöglicht individuellere Anpassungen an die Ausgabe. Dem Konstruktor kann ein Formatierungsstring übergeben werden, sozusagen eine Vorlage, wie die Zahlen zu formatieren sind. Die Formatierung einer Zahl durch DecimalFormat erfolgt mit Rücksicht auf die aktuell eingestellte Sprache.

Listing 4.16 DecimalFormatDemo.java, main()

double d = 12345.67890; 
DecimalFormat df = new DecimalFormat( "###,##0.00" ); 
System.out.println( df.format(d) );           // 12.345,68

Der Formatierungsstring kann eine Menge von Formatierungsanweisungen vertragen; im Beispiel kommen #, 0 und das Komma vor. Die beiden wichtigen Symbole sind jedoch 0 und #. Beide repräsentieren Ziffern. Der Unterschied tritt erst dann zu Tage, wenn weniger Zeichen zum Formatieren da sind, als im Formatierungsstring genannt werden.

Hier ein Beispiel für die Auswirkungen der Formatanweisungen auf einige Zahlen:

4.9.4 Ausgaben mit MessageFormat formatieren

MessageFormat ist eine konkrete Unterklasse der abstrakten Klasse Format und dient dazu, Nachrichten sprachunabhängig zu erzeugen. Das heißt, die tatsächliche sprachabhängige Ausgabe wird so weit wie möglich nach hinten geschoben und erst dann erzeugt, wenn die Nachricht dem Benutzer angezeigt werden soll. Durch MessageFormat werden nur Formatierungsanweisungen gegeben, und die wirklichen Informationen (also die Objekte als Informationsträger) werden zur Laufzeit eingesetzt. Dabei enthalten die Formatierungsanweisungen Platzhalter für diese Objekte. In der Regel werden Daten (die Argumente) erst zur Laufzeit ermittelt, wie etwa die Zeilennummer einer Fehlerstelle in einer Eingabedatei.

Object[] testArgs = { 31415L, "SchnelleLotte" }; 
MessageFormat form = new MessageFormat( 
    "Anzahl Dateien auf der Festplatte \"{1}\": {0}." ); 
System.out.println( form.format(testArgs) );

Anzahl Dateien auf der Festplatte "SchnelleLotte": 0. 
Anzahl Dateien auf der Festplatte "SchnelleLotte": 1. 
Anzahl Dateien auf der Festplatte "SchnelleLotte": 31,415.

Die Argumente aus dem Array werden über die Platzhalter wie {0} in die Nachricht eingefügt. Die Nummern entsprechen der Reihenfolge der Argumente im Array. Einträge im Array können ungenutzt bleiben. Fehlt allerdings das einem Platzhalter entsprechende Element im Feld, so wird eine ParseException ausgelöst.

class java.text.MessageFormat 
extends Format

• MessageFormat( String pattern ) Erzeugt ein MessageFormat-Objekt mit dem angegebenen Pattern.

Gegenüber anderen Format-Klassen zeigt die Klasse MessageFormat eine Besonderheit beim Erzeugen. MessageFormat-Objekte werden über ihren Konstruktor erzeugt und nicht über getInstance(). Der Grund ist, dass üblicherweise die Erzeugungsmethoden – damit sind die getInstance()-Varianten gemeint – eine komplexe Initialisierung durchlaufen, die die landesspezifischen Einstellungen festlegen. MessageFormat ist aber an keine bestimmte Sprache gebunden und benötigt folglich auch keine Initialisierung.

Bildungsgesetz für Message-Formate

Die Zeichenkette für MessageFormat enthält die Format-Elemente, die in geschweiften Klammern gesetzt sind. Steht dort nur der Index – wie {0} –, ist das der einfachste Fall. Die API-Dokumentation von MessageFormat zeigt jedoch, dass die Angaben auch präziser ausfallen können:

• { ArgumentIndex, FormatType }: Element wird nach dem angegebenen Format-Typ number, date, time oder choice formatiert. MessageFormat besorgt sich zum Beispiel im Fall vom Format-Typ number über NumberFormat.getInstance(getLocale()) einen passenden Formatierer.

• { ArgumentIndex, FormatType, FormatStyle }: Neben dem Format-Typ lässt sich der Stil festlegen. Vordefiniert sind short, medium, long, full, integer, currency und percent. Ein eigener Formatierungsstil lässt sich auch angeben, der aber zur Unterscheidung in einfachen Hochkommata eingeschlossen werden muss.

Abschließend sei ein Beispiel mit MessageFormat gegeben, das das gleiche Argument unterschiedlich formatiert:

Listing 4.17 MessageFormatDemo.java, main()

Object[] arguments = { 
  new Date(), 
  "die Antwort auf alle Fragen", 
  42                                     // Integer object 
}; 
 
String result = MessageFormat.format( 
  "Am {0,date} um {0,time} ist {1} wie immer {2,number,integer}.", 
  arguments ); 
 
System.out.println( result );

Dies erzeugt die Ausgabe:

Am 21.08.2007 um 15:43:56 ist die Antwort auf alle Fragen wie immer 42.

Ihr Kommentar