Formatierte Ausgabe mit Java (Formatierte Ausgabe mit Java), Lektion, Seite 723216
https://www.purl.org/stefan_ram/pub/formatierung_java (Permalink) ist die kanonische URI dieser Seite.
Stefan Ram
↑Java-Kurs

Formatierende Ausgabeanweisungen mit Java 

Die formatierende Ausgabe mit »java.lang.System.out.printf« erlaubt es, Ausgaben von Zahlen übersichtlich zu formatieren und verschiedene Arten von Ausgaben mit relativ wenig Programmieraufwand zu erzeugen.

»java.lang.System.out.printf«

Man man die Ausgabe mit »java.lang.System.out.printf« zunächst mit der Ausgabe mit »java.lang.System.out.print« vergleichen. In einfachen Fällen verhält sie sich wie diese.

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.print( "ab" );
    java.lang.System.out.println(); }}
transcript
ab
Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.printf( "ab" );
    java.lang.System.out.println(); }}
transcript
ab

Das folgende Programm gibt zwei Zeilen aus und schließt diese mit jeweils einem Zeilenabschluß ab, der durch »%n« dargestellt wird. (Hierfür sollte im allgemeinen nicht  »\n« verwendet werden, auch wenn dies manchmal zu funktionieren scheint.)

Diese Schreibweise »%n« steht aber nur in einer Zeichenfolge für ein Zeilenende, wenn diese der erste Ausdruck in den Klammern hinter »printf« ist. Auch die anderen in dieser Lektion behandelten Ausgabetechniken können nur mit »printf« und nicht mit den vorher behandelten Ausgaben mit »java.lang.System.out.print« und »java.lang.System.out.println« zusammen verwendet werden.

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( "a%nb%n" ); }}
transcript
a%nb%n
Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.printf( "a%nb%n" ); }}
transcript
a
b

Das voranstehende Programm ist gleichbedeutend zu dem folgenden Programm.

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( "a" );
    java.lang.System.out.println( "b" ); }}
transcript
a
b

Auch das folgende Programm hat dieselbe Bedeutung.

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( "a" + java.lang.System.lineSeparator() + "b" ); }}
transcript
a
b

Vergleich mit »java.lang.String.format«

Die Ausdrücke, welche man in die Klammern hinter »java.lang.System.out.printf« schreiben kann, sie so, wie dies schon zuvor für die Methode »java.lang.String.format« erklärt wurde. Der Unterschied besteht nur darin, daß »java.lang.System.out.printf« den sich ergebenen Text ausgibt, während »java.lang.String.format« ihn zurückgibt.

Bei den beiden folgenden Beispielprogrammen wird einmal »java.lang.String.format« und einmal »java.lang.System.out.printf« verwendet.

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.print
    ( java.lang.String.format( "%s%n%f%n", 0.000001, 0.000001 )); }}
transcript
1.0E-6
0,000001
transcript
1.0E-6
0.000001
Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.printf( "%s%n%f%n", 0.000001, 0.000001 ); }}
transcript
1.0E-6
0,000001
transcript
1.0E-6
0.000001

Feldbreiten

Da wir nun auch mehrere Ausgabeanweisungen hintereinander in eine Programm schreiben können, sind wir in der Lage hier noch einige weiter Beispiele zu Anwendungsmöglichkeiten der Formatierung zu zeigen, die sowohl mit »printf« als auch mit »format« verwendet werden können.

Nach einem Prozentzeichen kann auch noch ein ganzzahliges Numerale eingefügt werden, welches eine Ausgabefeldbreite  angibt.

Die Ausgaben werden dann rechtsbündig  in das links mit Leerzeichen aufgefüllte Feld geschrieben, was die Ausrichtung von Spalten in Tabellen erleichtert.

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.printf( "%s%n",    1 );
    java.lang.System.out.printf( "%s%n",   12 );
    java.lang.System.out.printf( "%s%n",  123 );
    java.lang.System.out.printf( "%3s%n",   1 );
    java.lang.System.out.printf( "%3s%n",  12 );
    java.lang.System.out.printf( "%3s%n", 123 ); }}
transcript
1
12
123
  1
 12
123
Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.printf( "%5s %5s %5s %5s%n", "A", "B", "C", "D" );
    java.lang.System.out.printf( "%5s %5s %5s %5s%n",   1, 321,   1, 321 );
    java.lang.System.out.printf( "%5s %5s %5s %5s%n",  12,  12,  12,  12 );
    java.lang.System.out.printf( "%5s %5s %5s %5s%n", 123,   1, 123,   1 ); }}
transcript
    A     B     C     D
    1   321     1   321
   12    12    12    12

Ein Minuszeichen  bei der Feldbreite verlangt die linksbündige  Ausrichtung in dem Feld mit der angegebenen Breite.

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.printf( "%-5s %-5s %-5s %-5s%n", "A", "B", "C", "D" );
    java.lang.System.out.printf( "%5s %5s %5s %5s%n",   1, 321,   1, 321 );
    java.lang.System.out.printf( "%5s %5s %5s %5s%n",  12,  12,  12,  12 );
    java.lang.System.out.printf( "%5s %5s %5s %5s%n", 123,   1, 123,   1 ); }}
transcript
A     B     C     D    
    1   321     1   321
   12    12    12    12
  123     1   123     1

Die Angabe der Anzahl der Nachkommastellen kann auch mit der Angabe einer Feldbreite  kombiniert werden.

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.printf( "EUR %6.2f%n",   2.38626622 );
    java.lang.System.out.printf( "USD %6.2f%n", 412.         );
    java.lang.System.out.printf( "DEM %6.2f%n",  11.7        ); }}
transcript
EUR   2,39
USD 412,00
DEM  11,70
transcript
EUR   2.39
USD 412.00
DEM  11.70

Syntax der printf-Ausgabeanweisung

Ausgabeanweisung (Syntaxdiagramm)
Ausgabeanweisung
      .----.      .-.      .----.      .-.      .------.      .-.   
---->( java )--->( . )--->( lang )--->( . )--->( System )--->( . )---.
      '----'      '-'      '----'      '-'      '------'      '-'    |
                                                                     |
.--------------------------------------------------------------------'
|
|     .---.      .-.      .------.     
'--->( out )--->( . )--->( printf )----.
      '---'      '-'      '------'     |
                                       |
.--------------------------------------'
|  
|     .-.         .----------.         .-.      .-.
'--->( ( )---.--->| Ausdruck |---.--->( ) )--->( ; )--->
      '-'    ^    '----------'   |     '-'      '-'
             |         .-.       |
             '--------( , )------'
                       '-'

Wir nennen den Ausdruck in einer Ausgabeanweisung auch das Argument  jener Ausgabeanweisung. Bei mehreren durch ein Komma getrennten Ausdrücken, ist jeder einzelne Ausdruck ein Argument.

Beispiel

Vorher:

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.printf( "%5s %5s %5s %5s%n", "A", "B", "C", "D" );
    java.lang.System.out.printf( "%5s %5s %5s %5s%n",   1, 321,   1, 321 );
    java.lang.System.out.printf( "%5s %5s %5s %5s%n",  12,  12,  12,  12 );
    java.lang.System.out.printf( "%5s %5s %5s %5s%n", 123,   1, 123,   1 ); }}
transcript
    A     B     C     D
    1   321     1   321
   12    12    12    12
  123     1   123     1

Hinterher:

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { final java.lang.String format = "%5s %5s %5s %5s%n";
    java.lang.System.out.printf( format, "A", "B", "C", "D" );
    java.lang.System.out.printf( format,   1, 321,   1, 321 );
    java.lang.System.out.printf( format,  12,  12,  12,  12 );
    java.lang.System.out.printf( format, 123,   1, 123,   1 ); }}
transcript
    A     B     C     D
    1   321     1   321
   12    12    12    12
  123     1   123     1

Die Wiederholung des langen und komplizierten Zeichenfolgenliterals »"%5s %5s %5s %5s%n"« wurde oben ersetzt durch die Wiederholung des kurzen und einfachen Namens »format«.

ℛ Stilregel Wiederholungen sollten möglichst ganz vermieden werden, aber etwas Kurzes und Einfaches zu wiederholen ist besser, als etwas Langes und Kompliziertes zu wiederholen. Jede Information soll nur einmal  im Programm vorkommen, damit sie leicht durch eine Änderung an einer einzigen Stelle  geändert werden kann.

Man könnte dieses Prinzip noch weiterführen:

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { final int width = 5;
    final java.lang.String conversion = "%" + width + "s";
    final java.lang.String format = conversion + " " +
                                    conversion + " " +
                                    conversion + " " +
                                    conversion + " " + "\n";
    java.lang.System.out.printf( format, "A", "B", "C", "D" );
    java.lang.System.out.printf( format,   1, 321,   1, 321 );
    java.lang.System.out.printf( format,  12,  12,  12,  12 );
    java.lang.System.out.printf( format, 123,   1, 123,   1 ); }}
Protokoll
    A     B     C     D 
    1   321     1   321 
   12    12    12    12 
  123     1   123     1

Nun kann die Breite aller Spalten auf einfache Weise durch eine Änderung an einer einzigen Stelle geändert werden.

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { final int width = 3;
    final java.lang.String conversion = "%" + width + "s";
    final java.lang.String format = conversion + " " +
                                    conversion + " " +
                                    conversion + " " +
                                    conversion + " " + "\n";
    java.lang.System.out.printf( format, "A", "B", "C", "D" );
    java.lang.System.out.printf( format,   1, 321,   1, 321 );
    java.lang.System.out.printf( format,  12,  12,  12,  12 );
    java.lang.System.out.printf( format, 123,   1, 123,   1 ); }}
Protokoll
  A   B   C   D 
  1 321   1 321 
 12  12  12  12 
123   1 123   1
Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { final int width = 9;
    final java.lang.String conversion = "%" + width + "s";
    final java.lang.String format = conversion + " " +
                                    conversion + " " +
                                    conversion + " " +
                                    conversion + " " + "\n";
    java.lang.System.out.printf( format, "A", "B", "C", "D" );
    java.lang.System.out.printf( format,   1, 321,   1, 321 );
    java.lang.System.out.printf( format,  12,  12,  12,  12 );
    java.lang.System.out.printf( format, 123,   1, 123,   1 ); }}
Protokoll
        A         B         C         D 
        1       321         1       321 
       12        12        12        12 
      123         1       123         1

Übersetzung von Zahlen ins Deutsche ⃗

Das folgende Programm enthält eine Methode »deutsch«, welche einige Zahlen durch deutsche Wörter darstellt.

Main.java
public final class Main 
{
  public static java.lang.String deutsch( final int i )
  { return java.lang.String.format
    ( "%" + i + "$s", "Eins", "Zwei", "Drei" ); }
  public static void printDeutsch( final int i )
  { java.lang.System.out.println( deutsch( i )); }
  public static void main( final java.lang.String[] args ) 
  { printDeutsch( 1 );
    printDeutsch( 2 );
    printDeutsch( 3 ); }}
Protokoll
Eins
Zwei
Drei

Beispiel

In dem folgenden Programm haben die die Konstanten »text« beispielsweise einen kleinen Gültigkeitsbereich. Dadurch ist es sofort erkennbar, daß jede Konstante »text« nur zu der ihrer Deklaration direkt folgenden Ausgabeanweisung gehört und danach nicht mehr benötigt wird.

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { final java.lang.String kehrreim = "Sim sa la dim, bam ba,%nSa la du, sa la dim -%n";
    { final java.lang.String text = "Auf einem Baum ein Kuckuck";
      java.lang.System.out.printf( "%s, -%n" + kehrreim + "%s sass.%n%n", text, text ); }
    { final java.lang.String text = "Da kam ein junger Jaeger";
      java.lang.System.out.printf( "%s, -%n" + kehrreim + "%ssmann.%n%n", text, text ); }
    { final java.lang.String text = "Der schoss den armen Kuckuck";
      java.lang.System.out.printf( "%s, -%n" + kehrreim + "%s tot.%n",    text, text ); }}}
Protokoll
Auf einem Baum ein Kuckuck, -
Sim sa la dim, bam ba,
Sa la du, sa la dim -
Auf einem Baum ein Kuckuck sass.

Da kam ein junger Jaeger, -
Sim sa la dim, bam ba,
Sa la du, sa la dim -
Da kam ein junger Jaegersmann.

Der schoss den armen Kuckuck, -
Sim sa la dim, bam ba,
Sa la du, sa la dim -
Der schoss den armen Kuckuck tot.

In dem folgenden Text wurde der Gültigkeitsbereich der drei Konstanten »text« nun unnötig vergrößert: Es kommt zu einer Namenskollision, und es ist nicht mehr erkennbar, welche Konstante zu welcher Ausgabeanweisung gehört.

Main.txt
public final class Main
{ public static void main( final java.lang.String[] args )
  { final java.lang.String kehrreim = "Sim sa la dim, bam ba,%nSa la du, sa la dim -%n";
    final java.lang.String text = "Auf einem Baum ein Kuckuck";
    final java.lang.String text = "Da kam ein junger Jaeger";
    final java.lang.String text = "Der schoss den armen Kuckuck"; 
    java.lang.System.out.printf( "%s, -%n" + kehrreim + "%s sass.%n%n", text, text );
    java.lang.System.out.printf( "%s, -%n" + kehrreim + "%ssmann.%n%n", text, text );
    java.lang.System.out.printf( "%s, -%n" + kehrreim + "%s tot.%n",    text, text ); }}
Protokoll
error: variable text is already defined in method main(String[])
    final java.lang.String text = "Da kam ein junger Jaeger";
                           ^
error: variable text is already defined in method main(String[])
    final java.lang.String text = "Der schoss den armen Kuckuck"; 
                           ^
2 errors

In dem folgenden Text wurden die Konstanten »text« nun umbenannt, um die Namenskollision zu vermeiden. Das Programm kann nun zwar wieder gestartet werden, aber es ist schwieriger zu erkennen, wo eine Konstante verwendet wird. Außerdem sind nun gewisse Formen der Überarbeitung des Programms, die wir erst später behandeln werden, erschwert. Da der passende Name »text« nicht mehr für alle Variablen verwendet werden konnte, mußte auf schlechtere Namen wie »text2« ausgewichen werden, die bedeutungslose Ziffern enthalten.

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { final java.lang.String kehrreim = "Sim sa la dim, bam ba,%nSa la du, sa la dim -%n";
    final java.lang.String text0 = "Auf einem Baum ein Kuckuck";
    final java.lang.String text1 = "Da kam ein junger Jaeger";
    final java.lang.String text2 = "Der schoss den armen Kuckuck"; 
    java.lang.System.out.printf( "%s, -%n" + kehrreim + "%s sass.%n%n", text0, text0 );
    java.lang.System.out.printf( "%s, -%n" + kehrreim + "%ssmann.%n%n", text1, text1 );
    java.lang.System.out.printf( "%s, -%n" + kehrreim + "%s tot.%n",    text2, text2 ); }}
Protokoll
Auf einem Baum ein Kuckuck, -
Sim sa la dim, bam ba,
Sa la du, sa la dim -
Auf einem Baum ein Kuckuck sass.

Da kam ein junger Jaeger, -
Sim sa la dim, bam ba,
Sa la du, sa la dim -
Da kam ein junger Jaegersmann.

Der schoss den armen Kuckuck, -
Sim sa la dim, bam ba,
Sa la du, sa la dim -
Der schoss den armen Kuckuck tot.

Natürlich könnte man das ganze Programm insgesamt auch noch etwas kürzer machen.

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { final java.lang.String satz = "Dieses hier ist ein sehr langer Satz, der nun wirklich sehr lang ist.";
    java.lang.System.out.printf( "%1$s%n%1$s%n%1$s%n", satz ); }}
transcript
Dieses hier ist ein sehr langer Satz, der nun wirklich sehr lang ist.
Dieses hier ist ein sehr langer Satz, der nun wirklich sehr lang ist.
Dieses hier ist ein sehr langer Satz, der nun wirklich sehr lang ist.

Ausgabe eines Liedes

Wir können die Ausgabe eines Liedes nun mit noch weniger Wiederholungen programmieren. Unser Programm verdeutlicht tatsächlich auch das Aufbauprinzip des Textes.

Main.java
public final class Main
{ 
  public static void strophe
  ( final java.lang.String text, final java.lang.String addendum )
  { java.lang.System.out.printf
    ( "%s, -%nSim sa la dim, bam ba,%nSa la du, sa la dim -%n%s%s.%n%n",
      text, text, addendum ); }
  public static void main( final java.lang.String[] args )
  { strophe( "Auf einem Baum ein Kuckuck",   " sass" );
    strophe( "Da kam ein junger Jaeger",     "smann" );
    strophe( "Der schoss den armen Kuckuck", " tot" ); }}
Protokoll

Auf einem Baum ein Kuckuck, -
Sim sa la dim, bam ba,
Sa la du, sa la dim -
Auf einem Baum ein Kuckuck sass.

Da kam ein junger Jaeger, -
Sim sa la dim, bam ba,
Sa la du, sa la dim -
Da kam ein junger Jaegersmann.

Der schoss den armen Kuckuck, -
Sim sa la dim, bam ba,
Sa la du, sa la dim -
Der schoss den armen Kuckuck tot.


java.lang.System.out.printf( "%a%n", maximum ); /* 0x1.fffffffffffffp1023 */
Kombination der if-Anweisung mit einem Prädikat ⃗

Main.java
public final class Main
{ public static void main( final java.lang.String[] args)
  { java.lang.System.out.printf( "%c%n", 64 );
    java.lang.System.out.printf( "%c%n", 65 ); }}
transcript
@
A
Main.java
public final class Main
{ public static void main( final java.lang.String[] args)
  { java.lang.System.out.println( java.lang.Character.isLetter( 64 ));
    java.lang.System.out.println( java.lang.Character.isLetter( 65 )); }}
transcript
false
true
Main.java
public final class Main
{ 
  public static void check( final int c )
  { if( java.lang.Character.isLetter( c )== false )
    java.lang.System.out.printf
    ( "Das Zeichen '%c' ist kein Buchstabe.%n", c ); }
  public static void main( final java.lang.String[] args)
  { check( 64 );
    check( 65 ); }}
transcript
Das Zeichen '@' ist kein Buchstabe.

Zeichentabelle

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { int i = 32; while( i != 127 )
    { java.lang.System.out.printf( "%1$c %1$3d%n", i );
      i = i + 1; }}}
transcript
   32
!  33
"  34
#  35
$  36
%  37
&  38
'  39
(  40
)  41
*  42
+  43
,  44
-  45
.  46
/  47
0  48
1  49
2  50
3  51
4  52
5  53
6  54
7  55
8  56
9  57
:  58
;  59
<  60
=  61
>  62
?  63
@  64
A  65
B  66
C  67
D  68
E  69
F  70
G  71
H  72
I  73
J  74
K  75
L  76
M  77
N  78
O  79
P  80
Q  81
R  82
S  83
T  84
U  85
V  86
W  87
X  88
Y  89
Z  90
[  91
\  92
]  93
^  94
_  95
`  96
a  97
b  98
c  99
d 100
e 101
f 102
g 103
h 104
i 105
j 106
k 107
l 108
m 109
n 110
o 111
p 112
q 113
r 114
s 115
t 116
u 117
v 118
w 119
x 120
y 121
z 122
{ 123
| 124
} 125
~ 126

Zeichentabelle mit Prädikaten

Die Formate »%03x« und »%03o« verlangen die Ausgabe mit drei Ziffern im hexadezimal- beziehungsweise Oktalsystem.

Aussprachehinweis
alphabetic ˌæl fə ˈbɛt ɪk (sd)
Main.java
public final class Main
{ 
  public static void printHeading
  ( final java.lang.String prefix,
    final java.lang.String suffix )
  { java.lang.System.out.printf( prefix + "C DEZ HX OCT Z B leer" + suffix ); }
    
  public static void main( final java.lang.String[] args )
  { printHeading( "", "%n%n" );
    int i = 32; while( i != 127 )
    { java.lang.System.out.printf
      ( "%c %1$3d %1$02x %1$03o %s %s %s %n", 
        i,
        java.lang.Character.isDigit(      i )? "Z"    : " ",
        java.lang.Character.isAlphabetic( i )? "B"    : " ",
        java.lang.Character.isSpaceChar(  i )? "leer" : "    " );
      i = i + 1; }
    printHeading( "%n", "%n" ); }}
transcript
C DEZ HX OCT Z B leer

   32 20 040     leer 
!  33 21 041          
"  34 22 042          
#  35 23 043          
$  36 24 044          
%  37 25 045          
&  38 26 046          
'  39 27 047          
(  40 28 050          
)  41 29 051          
*  42 2a 052          
+  43 2b 053          
,  44 2c 054          
-  45 2d 055          
.  46 2e 056          
/  47 2f 057          
0  48 30 060 Z        
1  49 31 061 Z        
2  50 32 062 Z        
3  51 33 063 Z        
4  52 34 064 Z        
5  53 35 065 Z        
6  54 36 066 Z        
7  55 37 067 Z        
8  56 38 070 Z        
9  57 39 071 Z        
:  58 3a 072          
;  59 3b 073          
<  60 3c 074          
=  61 3d 075          
>  62 3e 076          
?  63 3f 077          
@  64 40 100          
A  65 41 101   B      
B  66 42 102   B      
C  67 43 103   B      
D  68 44 104   B      
E  69 45 105   B      
F  70 46 106   B      
G  71 47 107   B      
H  72 48 110   B      
I  73 49 111   B      
J  74 4a 112   B      
K  75 4b 113   B      
L  76 4c 114   B      
M  77 4d 115   B      
N  78 4e 116   B      
O  79 4f 117   B      
P  80 50 120   B      
Q  81 51 121   B      
R  82 52 122   B      
S  83 53 123   B      
T  84 54 124   B      
U  85 55 125   B      
V  86 56 126   B      
W  87 57 127   B      
X  88 58 130   B      
Y  89 59 131   B      
Z  90 5a 132   B      
[  91 5b 133          
\  92 5c 134          
]  93 5d 135          
^  94 5e 136          
_  95 5f 137          
`  96 60 140          
a  97 61 141   B      
b  98 62 142   B      
c  99 63 143   B      
d 100 64 144   B      
e 101 65 145   B      
f 102 66 146   B      
g 103 67 147   B      
h 104 68 150   B      
i 105 69 151   B      
j 106 6a 152   B      
k 107 6b 153   B      
l 108 6c 154   B      
m 109 6d 155   B      
n 110 6e 156   B      
o 111 6f 157   B      
p 112 70 160   B      
q 113 71 161   B      
r 114 72 162   B      
s 115 73 163   B      
t 116 74 164   B      
u 117 75 165   B      
v 118 76 166   B      
w 119 77 167   B      
x 120 78 170   B      
y 121 79 171   B      
z 122 7a 172   B      
{ 123 7b 173          
| 124 7c 174          
} 125 7d 175          
~ 126 7e 176          

C DEZ HX OCT Z B leer

Beschreibung der Syntax und Semantik von Formatspezifizierern (vereinfacht) ⃗

Formatspezifizierer

Morphologisches Diagramm
Formatspezifizierer
        .-.     .----------.    .----------.    .------------.    .-------------.    .------------.
|-|--->( % )--->| Position |--->| Optionen |--->| Feldbreite |--->| Genauigkeit |--->| Unwandlung |--->|-|
        '-'     '----------'    '----------'    '------------'    '-------------'    '------------'

Position

Position
Position
      .-----------------------------------------.
      |        .---------------.         .-.    v
|-|---'---.--->| Dezimalziffer |---.--->( $ )---'--->|-|
          ^    '---------------'   |     '-'
          '------------------------'

Es wird das Zusatzargument bei der angegebenen Position ausgewählt. Die Ziffernfolge wird im Dezimalsystem interpretiert, führende Nullen werden toleriert und ignoriert. Die Position des ersten Zusatzarguments (also des ersten Arguments direkt nach dem Formatspezifizierer) ist »1«.

Optionen

Optionen
Optionen
      .--------------------.
      |         .-.        v
|-|---'---.--->( 0 )---.---'--->
          |     '-'    |
          |     .-.    |
          '--->( , )---'
                '-'

Durch die Angabe einer »0« wird die Option »0« gesetzt. Welche Bedeutung diese Option hat, hängt von der angegebenen Umwandlung ab und wird dort (weiter unten) beschrieben.

Feldbreite

Feldbreite
Feldbreite
      .--------------------------------.
      |        .---------------.       v
|-|---'---.--->| Dezimalziffer |---.---'--->|-|
          ^    '---------------'   |  
          '------------------------'

Die Ziffernfolge wird im Dezimalsystem interpretiert. Es wird die angegebene Feldbreite festgelegt.

Hier sind führende Nullen nicht erlaub.

Genauigkeit

Genauigkeit
Genauigkeit
      .------------------------------------------.
      |     .-.          .---------------.       v
|-|---'--->( . )--->.--->| Dezimalziffer |---.---'--->|-|
            '-'     ^    '---------------'   |  
                    '------------------------'

Es wird die angegebene Genauigkeit festgelegt.

Die Ziffernfolge wird im Dezimalsystem interpretiert, führende Nullen werden toleriert und ignoriert.

Umwandlung

Umwandlung
Umwandlung      
            .-.
|-|---.--->( n )--->.--->|-|
      |     '-'     ^
      |     .-.     |
      '--->( s )----'
      |     '-'     |
      |     .-.     |
      '--->( f )----'
      |     '-'     |
      |     .-.     |
      '--->( c )----'
      |     '-'     |
      |     .-.     |
      '--->( d )----'
      |     '-'     |
      |     .-.     |
      '--->( x )----'
      |     '-'     |
      |     .-.     |
      '--->( o )----'
      |     '-'     |
      |     .-.     |
      '--->( % )----'
            '-'

»n«

Die Umwandlung »n« ergibt ein Zeilenende. Die Angabe einer Position wird ignoriert. Eine Angabe von Optionen, Feldbreite oder Genauigkeit ist nicht zulässig.

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println
    ( java.lang.String.format( "a%nb" )); }}
Protokoll
a
b

»s«

Die Umwandlung »s« ergibt die Umwandlung des zugehörigen Arguments in eine Zeichenfolge.

Eine Angabe der Option »0« oder der Option »,« ist hier nicht zulässig.

Eine angegebene Feldbreite wird berücksichtigt, indem nötigenfalls von links mit Leerzeichen aufgefüllt wird.

Die Genauigkeit gibt hier die maximale Anzahl von Zeichen an, die zur Darstellung des auszugebenden Wertes verwendet werden sollen.

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println
    ( java.lang.String.format( "]%6.3s[", "abcdef" )); }}
Protokoll
]   abc[

»f«

Die Umwandlung »f« ergibt die Darstellung des zugehörigen double-Arguments als Numerale.

Bei Angabe der Option »,« werden Tausendertrennzeichen eingefügt.

Eine angegebene Feldbreite wird berücksichtigt, indem nötigenfalls von links mit Leerzeichen aufgefüllt wird. Bei Angabe der Option »0« wird statt dessen von links mit Nullen »0« aufgefüllt.

Die Genauigkeit gibt hier die gewünschte Anzahl von Nachkommastellen an. (Es wird gegebenenfalls gerundet.)

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println
    ( java.lang.String.format( "%,09.4f", 321.123456789 )); }}
Protokoll
0321.1235

»c«

Die Umwandlung »s« ergibt die Umwandlung in das Zeichen, dessen Kennzahl (in Unicode ) durch den zugehörigen Argumentwert angegeben wird.

Eine Angabe der Option »0« oder der Option »,« ist hier nicht zulässig.

Eine angegebene Feldbreite wird berücksichtigt, indem nötigenfalls von links mit Leerzeichen aufgefüllt wird.

Eine Angabe einer Genauigkeit ist hier nicht zulässig.

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println
    ( java.lang.String.format( "|%2c", 65 )); }}
Protokoll
| A

»d«, »x«, »o«

Die Umwandlung »d«, »x« oder »o« ergibt die Darstellung eines int-Arguments im Dezimal-, Hexadezimal- beziehungsweise Oktal-System.

Die Option »,« ist für »x« oder »o« nicht zulässig, ansonsten haben die Optionen dieselbe Bedeutung wie bei der Umwandlung »f«.

Eine angegebene Feldbreite wird berücksichtigt, indem nötigenfalls von links mit Leerzeichen aufgefüllt wird.

Eine Angabe einer Genauigkeit ist hier nicht zulässig.

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println
    ( java.lang.String.format( "|%0,9d", 10023 )); }}
Protokoll
|00010.023
Protokoll
|00010,023

»%«

Das Ergebnis der Umwandlung ist ein Prozentzeichen.

Eine Angabe der Option »0« oder der Option »,« ist hier nicht zulässig.

Eine Angabe einer Feldbreite wird ignoriert.

Eine Angabe einer Genauigkeit ist hier nicht zulässig.

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println
    ( java.lang.String.format( "|%9%", 10023 )); }}
Protokoll
|%

Seiteninformationen und Impressum   |   Mitteilungsformular  |   "ram@zedat.fu-berlin.de" (ohne die Anführungszeichen) ist die Netzpostadresse von Stefan Ram.   |   Eine Verbindung zur Stefan-Ram-Startseite befindet sich oben auf dieser Seite hinter dem Text "Stefan Ram".)  |   Der Urheber dieses Textes ist Stefan Ram. Alle Rechte sind vorbehalten. Diese Seite ist eine Veröffentlichung von Stefan Ram. Schlüsselwörter zu dieser Seite/relevant keywords describing this page: Stefan Ram Berlin slrprd slrprd stefanramberlin spellched stefanram723216 stefan_ram:723216 Formatierte Ausgabe mit Java Stefan Ram, Berlin, and, or, near, uni, online, slrprd, slrprdqxx, slrprddoc, slrprd723216, slrprddef723216, PbclevtugFgrsnaEnz Erklärung, Beschreibung, Info, Information, Hinweis,

Der Urheber dieses Textes ist Stefan Ram. Alle Rechte sind vorbehalten. Diese Seite ist eine Veröffentlichung von Stefan Ram.
https://www.purl.org/stefan_ram/pub/formatierung_java