4.7 Formatieren von Ausgaben 

Zahlen, Datumsangaben und Text können auf verschiedenste Art und Weise formatiert werden. Dabei unterscheiden sich zwei Lösungen:

Formatieren über Format-Klassen. Allgemeines Formatierungsverhalten wird in einer abstrakten Klasse Format fixiert. Sie definiert die Funktionalität, um zum einen (landes-) sprachabhängige Ausgaben zu erzeugen und zum anderen eingegebene Zeichenketten entsprechend zu zerlegen. Dazu stellt die Klasse Format die Methoden format() und parseObject() bereit. Jede Zeichenkette, die vom Format-Objekt erzeugt wurde, ist auch mit dem Parser wieder einlesbar.

In Java 5 realisiert die format()-Funktion eine Ausgabe, so wie sie unter C mit printf() gesetzt wurde.

Im Java SDK erweitern drei Klassen Format: DateFormat, MessageFormat und NumberFormat. Sie übernehmen die Ein-/Ausgabe für Datumsangaben, für allgemeine Programmmeldungen und für Zahlen.

Hier klicken, um das Bild zu Vergrößern

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 ) Parsed 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, ParsePosition) 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 auch die folgenden Methoden:

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

static XXXFormat getInstance( Locale l ) Für ein Formatierungsobjekt mit den Formatierungsregeln für das angegebene Land.

Einige der Unterklassen implementieren ein noch spezielleres Verhalten. So zum Beispiel die Klasse NumberFormat, die mit getPercentInstance() und getCurrencyInstance() zwei Methoden zum angepassten Formatieren dieser speziellen Arten von Zahlen bietet.

Die Unterklassen von Format erlauben es dem Benutzer auch, weitere Objekte zu erzeugen, die an die speziellen Sprachbesonderheiten weiterer Länder angepasst sind. Unterklassen, die dem Benutzer diese Möglichkeiten erlauben, sollten die Abfrage der unterstützten Länder mit

public static Locale[] getAvailableLocales()

ebenso implementieren.

4.7.1 Prozente, Zahlen und Währungen ausgeben mit NumberFormat 

Für die häufigen Ausgaben als Prozentzahlen oder als Währungszahlen gibt es die speziellen statischen Funktionen getPercentInstance(), getNumberInstance(), getIntegerInstance() und getCurrencyInstance() jeweils in der parameterlosen Variante und in der Variante mit einem Locale-Objekt.

import java.text.NumberFormat;

public class ProzenteGeben
{
  public static void main( String args[] )
  {
    double prozent = 45.3;
    NumberFormat nf = NumberFormat.getPercentInstance();
    System.out.println( nf.format(prozent/100) );
  }
}

4.7.2 Ausgaben formatieren mit MessageFormat 

MessageFormat ist eine konkrete Unterklasse der abstrakten Klasse Format. Sie 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. (Ähnliche Leistung erreicht auch printf(), was seit Java 5 mit im Boot ist.) In der Regel werden Daten (die Argumente) erst zur Laufzeit ermittelt, wie etwa die Zeilennummer einer Fehlerstelle in einer Eingabedatei.

Object testArgs[] = { new Long(31415), "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. Einige Einträge im Array können ungenutzt bleiben. Fehlt allerdings das einem Platzhalter entsprechende Element im Feld, so wird eine ParseException geworfen.

class java.text.  MessageFormat  
extends Format
implements Cloneable, Serializable

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

Gegenüber anderen Format-Klassen zeigt die Klasse MessageFormat eine Besonderheit im 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 nicht an eine bestimmte Sprache gebunden, benötigt folglich auch keine Initialisierung.

Bildungsgesetz für Message-Formate

Der Mustertext für eine Nachricht kann für die einzelnen Platzhalter eine bestimmte Art der Formatierung vorschreiben. Ein Bildungsgesetz in Form einer Grammatik schreibt die Bauweise vor:

messageFormatPattern :=
  string ( "{" messageFormatElement "}" string )*

messageFormatElement := argument { "," elementFormat }

elementFormat := "time" { "," datetimeStyle }
  | "date" { "," datetimeStyle }
  | "number" { "," numberStyle }
  | "choice" { "," choiceStyle }

datetimeStyle := "short"
  | "medium"
  | "long"
  | "full"
  | dateFormatPattern

numberStyle := "currency"
  | "percent"
  | "integer"
  | numberFormatPattern

choiceStyle := choiceFormatPattern

Listing 4.7   MessageFormatDemo.java

import java.text.*;
import java.util.*;

public class MessageFormatDemo
{
  public static void main( String args[] )
  {
    Object[] arguments = {
      new Date(System.currentTimeMillis()),
      "die Antwort auf alle Fragen",
      new Integer(42)
    };
    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:

4.7.3 Dezimalzahlformatierung mit DecimalFormat 

Die Klasse DecimalFormat dient zur formatierten Ausgabe von Zahlen. Dem Konstruktor wird ein Formatierungs-String übergeben, 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.8   DezimalFormatTest.java

import java.text.*;

public class DezimalFormatTest
{
  public static void main( String args[] )
  {
    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.

4.7.4 Formatieren mit format() 

Die Klasse String stellt mit der statischen Funktion format() eine Methode bereit, Zeichenketten nach einer Vorgabe zu formatieren. Das ist ähnlich zu MessageFormat.

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

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

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

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

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

Die Anzahl der Format-Spezifizierer ist so groß und vielfältig, dass ein Blick in die API-Dokumentation auf jeden Fall nötig ist. Intern werkeln java.util.Formatter (keine java.text.Format-Objekte), die sich auch direkt verwenden lassen; dort ist auch die Dokumentation festgemacht.

Praktischerweise ist das Formatieren und Ausgeben 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:

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

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

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

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

Listing 4.9   PrintfDemo.java

public class PrintfDemo
{
  public static void main( String[] args )
  {
    int      i = 123;

    System.out.printf( "|%d| |%d|\n" ,       i, -i);    // |123| |-123|
    System.out.printf( "|%5d| |%5d|\n" ,     i, -i);    // |  123| | –123|
    System.out.printf( "|%-5d| |%-5d|\n" ,   i, -i);    // |123  | |-123 |
    System.out.printf( "|%+-5d| |%+-5d|\n" , i, -i);    // |+123 | |-123 |
    System.out.printf( "|%05d| |%05d|\n\n",  i, -i);    // |00123| |-0123|

    System.out.printf( "|%X| |%x|\n" , 0xabc, 0xabc );  // |ABC| |abc|
    System.out.printf( "|%08x| |%#x|\n\n" , 0xabc, 0xabc ); 
                                       // |00000abc| |0xabc|

    double d = 1234.5678;

    System.out.printf( "|%f| |%f|\n" ,          d, -d); 
                                       // |1234,567800| |-1234,567800|
    System.out.printf( "|%.2f| |%.2f|\n" ,      d, -d); 
// |1234,57| |-1234,57|
    System.out.printf( "|%10f| |%10f|\n" ,      d, -d); 
                                       // |1234,567800| |-1234,567800|
    System.out.printf( "|%10.2f| |%10.2f|\n" ,  d, -d); 
                                       // |   1234,57| |  –1234,57|
    System.out.printf( "|%010.2f| |%010.2f|\n", d, -d); 
                                       // |0001234,57| |-001234,57|

    String s = "Monsterbacke";

    System.out.printf( "\n|%s|\n" , s );
                                       // |Monsterbacke|
    System.out.printf( "|%20s|\n" , s );
                                       // |        Monsterbacke|
    System.out.printf( "|%-20s|\n" , s );
                                       // |Monsterbacke        |
    System.out.printf( "|%7s|\n" , s );
                                       // |Monsterbacke|
    System.out.printf( "|%.7s|\n" , s );
                                       // |Monster|
    System.out.printf( "|%20.7s|\n" , s );
                                       // |             Monster|
  }
}