5.8    Konvertieren zwischen Primitiven und Strings 

Bevor ein Datentyp auf dem Bildschirm ausgegeben, zum Drucker geschickt oder in einer ASCII-Datei gespeichert werden kann, muss ihn das Java-Programm in einen String konvertieren. Wenn wir etwa die Zahl 7 ohne Umwandlung ausgäben, hätten wir keine 7 auf dem Bildschirm, sondern einen Pieps aus dem Lautsprecher – je nach Implementierung. Auch umgekehrt ist eine Konvertierung wichtig: Gibt der Benutzer in einem Dialog sein Alter an, ist das zuerst immer ein String. Diesen muss die Anwendung in einem zweiten Schritt in eine Ganzzahl konvertieren, um etwa eine Altersabfrage zu realisieren.

 

5.8.1    Unterschiedliche Typen in String-Repräsentationen konvertieren 

Die statischen überladenen String.valueOf(…)-Methoden liefern die String-Repräsentation eines primitiven Werts oder eines Objekts.

String s1 = String.valueOf( 10 );                    // 10

String s2 = String.valueOf( Math.PI );               // 3.141592653589793

String s3 = String.valueOf( 1 < 2 );                 // true

Die valueOf(…)-Methode ist überladen, und insgesamt gibt es für jeden primitiven Datentyp eine Implementierung:

final class java.lang.String

implements CharSequence, Comparable<String>, Serializable

• static String valueOf(boolean b)

• static String valueOf(char c)

• static String valueOf(double d)

• static String valueOf(float f)

• static String valueOf(int i)

• static String valueOf(long l)
  
  Liefert die String-Repräsentation der primitiven Elemente.

• static String valueOf(char[] data)

• static String valueOf(char[] data, int offset, int count)
  
  Liefert vom char-Array oder einem Ausschnitt des char-Arrays ein String-Objekt.

Die Methode valueOf(Object)

Der valueOf(Object)-Methode kann ein beliebiges Objekt übergeben werden.

String r = String.valueOf( new java.awt.Point() );  // java.awt.Point[x=0,y=0]

String s = String.valueOf( java.nio.file.Paths.get( "." ) ); // .

String t = String.valueOf( java.time.LocalTime.now() ); // 09:48:28.047834

Da jedes Objekt eine toString()-Methode besitzt, delegiert valueOf(Object) einfach auf diese.

Listing 5.10    java/lang/String.java, valueOf()

public static String valueOf( Object obj ) {

  return (obj == null) ? "null" : obj.toString();

}

Die Implementierung von valueOf(Object obj) fragt für die String-Umsetzung einfach das Objekt obj selbst. Die Sonderbehandlung testet, ob null übergeben wurde, und liefert dann einen gültigen String mit dem Inhalt "null". Da String.valueOf(null) die Rückgabe »null« liefert, gibt auch eine Ausgabe wie System.out.println(null) den String null auf der Konsole aus, denn println(Object) ruft intern String.valueOf(…) auf. Genauso ergibt System.out. println(null + "0") die Ausgabe "null0", da null als Glied in der Additionskette steht.

final class java.lang.String

implements CharSequence, Comparable<String>, Serializable

• static String valueOf(Object obj)
  
  Ist obj ungleich null, liefert die Methode obj.toString(), andernfalls die Rückgabe »null«.

 

5.8.2    String-Inhalt in einen primitiven Wert konvertieren 

Für das Parsen eines Strings – zum Beispiel von "123" aus einer Benutzereingabe in die Ganzzahl 123 – ist nicht die Klasse String verantwortlich, sondern spezielle Klassen, die für jeden primitiven Datentyp vorhanden sind. Die Klassen deklarieren statische parseXXX(String)-Methoden, wie Tabelle 5.9 zeigt:

Tabelle 5.9    Methoden zum Konvertieren eines Strings in einen primitiven Typ

Für jeden primitiven Typ gibt es eine sogenannte Wrapper-Klasse mit parseXXX(String)-Konvertiermethoden. Die Bedeutung der Klassen erklärt Abschnitt 10.5, »Wrapper-Klassen und Autoboxing«, genauer. An dieser Stelle betrachten wir nur die Konvertierfunktionalität.

Beispiel mit Double.parseDouble(String)

Die Methode Double.parseDouble(String)[ 141 ](In der Version 6 gab es einen Fehler, der zu viel Aufregung führte: Eine Zahl konnte nicht geparst werden, und der Compiler bzw. die Laufzeitumgebung ging in eine Endlosschleife. Mehr zu dem Fehler findet sich unter http://www.exploringbinary.com/java-hangs-when-converting-2-2250738585072012e-308. ) wollen wir in einem Beispiel nutzen. Der Benutzer soll in einem grafischen Dialog nach einer Fließkommazahl gefragt werden, und von dieser Zahl sollen dann der Sinus und der Kosinus auf dem Bildschirm ausgegeben werden:

Listing 5.11    src/main/java/com/tutego/insel/string/SinusAndCosinus.java, Ausschnitt

String s = javax.swing.JOptionPane.showInputDialog( "Bitte Zahl eingeben" );

double value = Double.parseDouble( s );

System.out.println( "Sinus: "   + Math.sin( value ) );

System.out.println( "Kosinus: " + Math.cos( value ) );

parseXXX(String) und mögliche NumberFormatException-Fehler

Kann eine parseXXX(String)-Methode eine Konvertierung nicht durchführen, weil sich ein String wie "1lala2lö" eben nicht konvertieren lässt, dann löst sie eine NumberFormatException aus. Das ist auch der Fall, wenn parseDouble(String) als Dezimaltrenner ein Komma statt eines Punktes empfängt. Bei der statischen Methode parseBoolean(String) ist die Groß-/Kleinschreibung irrelevant.

stringWithNumber.matches("\\p{Digit}+")

parseXXX(…) und das Verhalten mit Plus, Minus und Leerzeichen

Repräsentiert ein String negative Zahlen, so beginnt der String mit einem »–«, positive Zahlen dürfen auch mit einem »+« beginnen. Die statische Konvertierungsmethode Integer.parseInt(String) schneidet keine Leerzeichen ab und würde einen Parserfehler melden, wenn der String etwa mit einem Leerzeichen endet. (Die Helden der Java-Bibliothek haben allerdings bei Float.parseFloat(…) und Double.parseDouble(…) anders gedacht: Hier wird die Zeichenkette vorher schlank getrimmt.)

String s = " 1234    ".trim();            // s = "1234"

int i = Integer.parseInt( s );            // i = 1234

Das, was bei einem String.valueOf(…) als Ergebnis erscheint – und das ist auch das, worauf zum Beispiel System.out.printXXX(…) basiert –, kann parseXXX(…) wieder in den gleichen Wert zurückverwandeln.

char c = s.charAt( 0 )

Lokalisiertes parseXXX(String)

Die parseXXX(…)-Methoden sind nicht lokalisiert, können also nur englisch formatierte Zeichenfolgen in primitive Werte umsetzen. Bei den Ganzzahlen ist das kein Problem, nur bei Fließkommazahlen ist das ein großes Problem, denn ein parseDouble("1,3") führt zur NumberFormatException, nur parseDouble("1.3") nicht. Für die Lösung des Problems gibt es zwei Ansätze. Einer ist, vorher den Dezimaltrenner in einen Punkt zu konvertieren:

String s = "3,1";

double d = Double.parseDouble( s.replace( ',', '.' ) );               // 3.1

Diese Lösung ist jedoch nicht gut. Viel besser ist es, auf Klassen zurückzugreifen, die lokalisiertes Parsen ermöglichen, etwa Scanner (wir kommen in Abschnitt 5.10.2 noch einmal auf diese Klasse zurück):

String s = "3,1";

double d = new Scanner( s ).useLocale( Locale.GERMANY ).nextDouble(); // 3.1

 

5.8.3    String-Repräsentation im Format Binär, Hex und Oktal * 

Neben den überladenen statischen String.valueOf(primitive)-Methoden, die eine Zahl als String-Repräsentation im vertrauten Dezimalsystem liefern, und den parseXXX(…)-Umkehrmethoden der Wrapper-Klassen gibt es weitere Methoden zum Konvertieren und Parsen in der

• binären (Basis 2),

• oktalen (Basis 8),

• hexadezimalen (Basis 16)

• und in der Darstellung einer beliebigen Basis (bis 36).

Die Methoden zum Bilden der String-Repräsentation sind nicht an String, sondern zusammen mit Methoden zum Parsen an den Klassen Integer und Long festgemacht.

String-Repräsentationen aufbauen

Zum einen gibt es in den Klassen Integer und Long die allgemeinen Klassenmethoden toString(int i, int radix) für eine beliebige Radix, und zum anderen gibt es Spezialmethoden für die Radix 2, 8 und 16.

final class java.lang.Integer

extends Number

implements Comparable<Integer>, Serializable

• static String toBinaryString(int i)

• static String toOctalString(int i)

• static String toHexString(int)
  
  Erzeugt eine Binärrepräsentation (Basis 2), Oktalzahlrepräsentation (Basis 8) oder Hexadezimalrepräsentation (Basis 16) der vorzeichenlosen Zahl.

• static String toString(int i, int radix)
  
  Erzeugt eine String-Repräsentation der Zahl zur angegebenen Basis.

final class java.lang.Long

extends Number

implements Comparable<Long>, Serializable

• static String toBinaryString(long i)

• static String toOctalString(long i)

• static String toHexString(long i)
  
  Erzeugt eine Binärrepräsentation (Basis 2), Oktalzahlrepräsentation (Basis 8) oder Hexadezimalrepräsentation (Basis 16) der vorzeichenlosen Zahl. Achtung: Wenn die Zahl negativ ist, wird i ohne Vorzeichen behandelt und 2³² addiert.

• static String toString(long i, int radix)
  
  Erzeugt eine String-Repräsentation der Zahl zur angegebenen Basis. Negative Zahlen bekommen auch ein negatives Vorzeichen.

Der Parametertyp ist int bzw. long und nicht byte. Dies führt zu Ausgaben, die einkalkuliert werden müssen. Genauso werden führende Nullen grundsätzlich nicht mit ausgegeben.

Tabelle 5.10    Beispiele für die »toHexString()«-Methode

Die Ausgaben mit printf(…) – bzw. die Formatierung mit String.format(…) – bieten eine Alternative, die in Abschnitt 5.11.1, »Formatieren und Ausgeben mit format()«, vorgestellt wird.

System.out.println( Integer.toHexString( -10 ) );  // fffffff6

System.out.println( Integer.toString( -10, 16 ) ); // -a

Parsen von String mit Radix

Eine Methode zum Konvertieren eines Strings in eine Ganzzahl für eine gegebene Basis findet sich in den Klassen Integer und Long. Nur in den Klassen Integer und Long gibt es die Unterstützung für eine Basis auch ungleich 10:

final class java.lang.Integer

extends Number

implements Comparable<Integer>, Serializable

• static int parseInt(String s)

• static int parseInt(String s, int radix)

final class java.lang.Long

extends Number

implements Comparable<Long>, Serializable

• static long parseLong(String s)

• static long parseLong(String s, int radix)

Einige Anwendungsfälle:

Tabelle 5.11    Beispiele für »Integer.parseInt()« mit unterschiedlichen Zahlenbasen

String string = Long.toString( 2656437647773L, 36 );

System.out.println( string );   // xwcmdz8d

long l = Long.parseLong( string, 36 );

System.out.println( l ); // 2656437647773

Parsen von Binär-, Oktal- und Hexadezimalzahlen

Im Fall von String-Konvertierung existieren für die Standardbasen 2, 8 und 16 spezielle Methoden wie toHexString(…), aber zum Parsen gibt es sie nicht. Eine Hexadezimalzahl verarbeitet parseInt(s, 16), denn eine Methode wie parseHex(String) steht nicht bereit.

int i = Integer.parseInt( "7fffffff", 16 ); // 2147483647

int j = Integer.parseInt( "80000000", 16 ); //  NumberFormatException

System.out.println( Integer.toString( -2147483648, 16 ) ); // -80000000

System.out.println( Integer.parseInt( "-80000000", 16 ) ); // -2147483648

 

5.8.4    parseXXX(…)- und printXXX()-Methoden in DatatypeConverter * 

Das javax.xml.bind-Paket bietet eine Klasse DatatypeConverter, die eigentlich für die Abbildung von XML-Typen auf Java-Typen gedacht ist, doch auch so einige nützliche Methoden bereitstellt. Wir finden in der Klasse statische parseXXX(String)-Methoden und printXXX(…)-Methoden: Die ersten konvertieren einen String in diverse Datentypen – etwa short parseShort(String) –, und die zweiten formatieren einen bestimmten Datentyp in einen String – etwa String printShort(short). Für die meisten Methoden gibt es mit String.valueOf(…) und den parseXXX(…)/toString(…)-Methoden in den Wrapper-Klassen bessere Alternativen, und die Umwandlung von Datumswerten und Fließkommazahlen ist nicht lokalisiert, doch hervorzuheben sind folgende zwei Methoden:

final class javax.xml.bind.DatatypeConverter

• static byte[] parseHexBinary(String lexicalXSDHexBinary)

• static String printHexBinary(byte[] val)

Mit diesen statischen Methoden können leicht Byte-Arrays in die String-Repräsentationen hexadezimal konvertiert werden. Das ist nötig, wenn etwa Bytes in einer Text-Konfigurationsdatei abgelegt werden sollen. DatatypeConverter bietet auch Methoden für eine Base64-Kodierung, allerdings sind die geschachtelten Klassen in java.util.Base64 üblicher.

byte[] bytes = { 1, 2, 3, (byte) 254, (byte) 255 };

String s1 = DatatypeConverter.printHexBinary( bytes );

String s2 = DatatypeConverter.printBase64Binary( bytes );

System.out.println( s1 ); // 010203FEFF

System.out.println( s2 ); // AQID/v8=

// Arrays.equals( bytes, DatatypeConverter.parseHexBinary( s1 ) ) == true

// Arrays.equals( bytes, DatatypeConverter.parseBase64Binary( s2 ) ) == true