Navigation überspringen

Strings formatieren

Nun haben wir gelernt, wie wir Text einlesen und verarbeiten können. Wenn wir Daten allerdings in Text umwandeln (und in Text-Dateien speichern) wollen, dann müssen wir diese Daten erst formatieren. Außerdem können wir mit dem formatieren von Strings dafür sorgen, dass der Text schön und einheitlich formatiert ist. Darum geht es in diesem Kapitel.

Formatieren mit format()

Immer wieder müssen Zahlen, Datumsangaben und Text auf verschiedenste Art und Weise formatiert werden. Die Klasse String stellt mit der Methode format() eine Möglichkeit bereit, Zeichenketten nach einer Vorgabe zu formatieren. Die grundlegende Schreibweise ist wie folgt:

// Deklaration & Initialisierung
String s = String.format(TEXT, ARGUMENTE);
 
// Ausgabe
println(String.format(TEXT, ARGUMENTE));

Dabei ist TEXT, der Text, der formatiert werden soll, auch Format-String genannt. Die ARGUMENTE sind Werte, die in den TEXT eingefügt werden können.

Schau dir einmal folgendes Beispiel an:

String s = String.format( "Hallo %s. Es gab einen Anruf von %s.", "Chris", "Joy" );
println( s );    
Hallo Chris. Es gab einen Anruf von Joy.

Erläuterung:

  • Der erste übergebene String ist der Format-String.
    • Er enthält neben den auszugebenden Zeichen weitere sogenannte Format-Spezifizierer, die dem Formatierer darüber Auskunft geben, wie er das Argument formatieren soll. %s steht für eine unformatierte Ausgabe eines Strings.
  • Nach dem Format-String folgen Argumente mit den Werten, auf die sich die Format-Spezifizierer beziehen.
    • In diesem Fall sind dies Arguemente zwei Strings ("Chris" und "Joy"), die an die Stellen der Format-Spezifierer eingefügt werden.

Format-Spezifierer

Schauen wir uns den Format-String mal genauer an. Er besteht aus Literalen (im Beispiel oben ist das "Hallo" und "Es gab einen Anruf") und Format-Spezifizieren. 
Format-Spezifizierer bestehen aus Flags, Breite, Genauigkeit und Konvertierungszeichen - in dieser Reihenfolge:

%[flags][breite][.genauigkeit]konvertierungszeichen

Die Formatspezifizierer in den eckigen Klammern sind optional.

Konvertierungszeichen

Das Konvertierungszeichen ist zwingend erforderlich und legt fest, wie das Argument formatiert ist. Konvertierungszeichen sind nur für bestimmte Datentypen gültig. Ein paar wichtige sind folgende:

  • s – formatiert Strings
  • d – formatiert Ganz- bzw. Dezimalzahlen
  • f – formatiert Gleitkommakommazahlen
  • t – formatiert Datum und Zeit
  • b – formatiert Wahrheitswerte

Wir schauen uns diese später noch genauer an.

Optionale Modifikatoren

Die anderen Modifikatoren sind optional:

  • [flags] definieren standardisierte Wege die Ausgabe zu formatieren und werden am häufigsten für Integers und Gleitkommazahlen verwendet.
  • [breite] legt die Breite für das Argument fest. Die Zahl legt das Minimum an Zeichen fest, die in der Ausgabe vorkommen müssen.
  • [.genauigkeit] legt die Nummer an Zeichen für die Genauigkeit  bei Gleitkommazahlen fest. Außerdem können wir damit die Länge eines Substrings festlegen.

Zeilenumbruch

Für einen Zeilenumbruch haben wir den %n Spezifierer:

println(String.format("Java%nZeilen%numbruch"));
Java
Zeilen
umbruch

Boolean Formatierung

Um Booleans zu formatieren verwenden wir %b. Das funktioniert wie folgt: Wenn der Wert true ist, wird true ausgegeben. Ansonsten wir false ausgegeben.

print(String.format("%b%n", null));           // Ausgabe false
print(String.format("%B%n", false));          // Ausgabe FALSE
print(String.format("%B%n", 5.3));            // Ausgabe TRUE
print(String.format("%b%n", "random text"));  // Ausgabe true

Hinweis: Wir können %B verwenden, um die Ausgabe in Großbuchstaben zu konvertieren. 

String Formatierung

Um einen einfachen String zu formatieren, verwenden wir s%.  Auch hier können wir %S verwenden, um Großbuchstaben zu erhalten:

print(String.format("'%s' %n", "Processing")); // Ausgabe 'Processing'
print(String.format("'%S' %n", "Processing")); // Ausgabe 'PROCESSING'

Wir können auch eine minimale Breite festlegen, also wie lang der String mindestens sein soll. Der String wird dann mit Leerzeichen "aufgefüllt":

print(String.format("Ich lerne '%15s' %n", "Processing")); // Ausgabe: Ich lerne '     Processing'!

Wenn wir unseren String linksbündig haben wollen, können wir das '-' Flag verwenden:

print(String.format("Ich lerne '%-15s'! %n", "Processing")); // Ausgabe: Ich lerne 'Processing     '!

Wir können auch ein Limit an Zeichen festlegen indem wir Genauigkeit verwenden:

print(String.format("Ich lerne '%6.4s'! %n", "Processing")); // Ausgabe: Ich lerne '  Proc'!

Die 4 gibt an, wieviele Zeichen wir von dem String haben wollen. 4 Zeichen bedeutet bei uns die ersten 4 Buchstaben von Processing, sprich Proc.
Die 6 ist optional und gibt an, wieviele Zeichen der String haben soll, den wir als Ausgabe zurückbekommen. Ist diese Zahl höher, als die Zahl nach dem Punkt, werden Leerzeichen eingefügt. In diesem Fall werden 2 Leerzeichen vor Proc eingefügt.

Ganzzahl Formatierung

Die format Funktion akzeptiert alle Ganzahlen, die in Java vorkommen (byte, short, int, long). Für diese verwenden wir %d:

print(String.format("eine Ganzzahl: %d%n", 10000)); // Ausgabe: eine Ganzzahl: 10000

Wenn wir ein Tausender-Trennzeichen in unserer Zahl möchten, können wir die "," flag verwenden:

print(String.format("eine Ganzzahl: %,d%n", 10000)); // Ausgabe: eine Ganzzahl: 10.000

Eine weitere mögliche flag ist die Klammer. Die Klammer sorgt dafür, das negative Zahlen in Klammern angezeigt werden. Wir können problemlos flags kombienieren, wenn wir mehrere verwenden möchten. Die Reihenfolge der flags ist egal:

print(String.format("eine Ganzzahl: %(,d%n", -10000)); // Ausgabe: eine Ganzzahl: (10.000)
print(String.format("eine Ganzzahl: %,(d%n", -10000)); // Ausgabe: eine Ganzzahl: (10.000)

Float und Double Formatierung

Um eine Fließkommazahl zu formatieren benötigen wir %f:

print(String.format("%f%n", 125.1473f)); // Ausgabe: 5,147301

Wir sehen, dass der %f Spezifierer standardmäßig 6 Nachkommastellen darstellt. Um das zu vermeiden müssen wir die Genauigkeit anpassen:

print(String.format("%7.2f%n", 125.1473f)); // Ausgabe: 125,15

Hier legen wir mit 7 die Breite der Zahl fest und mit 2 die Nachkommastellen. Die Breite von 7 hat hier die Folge, dass vor der Zahl 1 Leerzeichen ist. Dieses können wir auch mit Nullen füllen, indem wir vor die 7 eine 0 setzen:

print(String.format("%07.2f%n", 125.1473f)); // Ausgabe: 0125,15

Hinweis: Das Komma wird hier auch als Zeichen für die Breite gewertet.

Auf diese Weise können wir Zahlen aufgeben, die alle dieselbe Breite haben unabhängig davon wieviele Zeichen sie tatsächlich haben:

print(String.format("%07.1f%n", 1.1d));     // Ausgabe: 00001,1
print(String.format("%07.1f%n", 10.1d));    // Ausgabe: 00010,1
print(String.format("%07.1f%n", 100.1d));   // Ausgabe: 00100,1
print(String.format("%07.1f%n", 1000.1d));  // Ausgabe: 01000,1
print(String.format("%07.1f%n", 10000.1d)); // Ausgabe: 10000,1

Hinweis: Ist die hinter den Gleitkommazahlen das f bzw. das d aufgefallen? Bei einer Gleitkommazahl kann es sich ja entweder um einen float oder einen double handeln. Damit dein Progamm funktioniert musst du der format Funktion genau sagen, was du meinst. Das kannst du mithilfe der Buchstaben. Hängst du an die Kommazahl ein f, dann behandelt und speichert dein Programm die Zahl als float, mit einem d hingegen wird sie als double interpretiert.

Variablen in Format-Spezifieren

In manchen Fällen kann es vorkommen, dass ein String, der mithilfe von format formatiert wird z.B. ein variable Breite haben soll. Auch das ist möglich. Da es sich beim ersten Parameter in der format Funktion um einen "ganz normalen" String handelt, kannst du in diesen String auch genau so wie du es bisher kennst, Variablen einbinden mithilfe der Stringverkettung.

int kommastellen = 1;
 
while (kommastellen < 4) {
   print(String.format("%."+kommastellen+"f%n", 1f)); 
   kommastellen++;
}
1,0
1,00
1,000

Zusammenfassung

In diesem Abschnitt haben wir gelernt, wie wir Strings formatieren können.  format() formatiert einen Format-String mithilfe von Format-Spezifizieren und Argumenten:

String s = String.format(TEXT, ARGUMENTE);

Format-Spezifizierer bestehen aus Flags, Breite, Genauigkeit und Konvertierungszeichen:

%[flags][breite][.genauigkeit]konvertierungszeichen
  • Flags: Typische flags sind z.B. das Minus-Zeichen (-),  das Komma (,) als Tausender-Trennzeichen, das Leerzeichen (' ') bzw. die Null (0) und die Klammer (
  • Breite: Gibt an wie breit (wieviele Zeichen) der String sein soll. Hier werden auch Kommas und Nachkommastellen miteinberechnet
  • Genaugikeit: Gibt die Nachkommastellen an
  • Konvertierungszeichen: Legt fest von welchem Typ der vorliegende Wert ist, z.B. float, int oder boolean. Wird das Konvertierungszeichen groß geschrieben, wird auch der String groß geschrieben.

Made with eXeLearning (New Window)