numbers-and-strings

Numbers & Strings

Kurz: Die Umwandlung zwischen Zahl und Text in beide Richtungen — Zahl zu String mit String.valueOf(zahl) oder Verkettung, String zu Zahl mit Integer.parseInt(text)/Double.parseDouble(text).

Genauer: parseInt/parseDouble werfen eine NumberFormatException, wenn der String kein gültiges Zahlenformat enthält (z. B. Buchstaben oder ein leerer String) — bei Nutzereingaben deshalb meist in einem try/catch abgesichert.

int zahl = Integer.parseInt("42");
String text = String.valueOf(42);

Im Detail

// Zahl -> Text
int zahl = 42;
String a = String.valueOf(zahl);   // "42"
String b = "" + zahl;               // "42" - funktioniert, aber unüblich/weniger klar
String c = Integer.toString(zahl); // "42"
 
// Text -> Zahl, mit Absicherung gegen ungültige Eingaben
String eingabe = "abc";
try {
    int wert = Integer.parseInt(eingabe);
} catch (NumberFormatException e) {
    System.out.println("'" + eingabe + "' ist keine gültige Zahl");
}
 
// Wrapper-Klassen bieten dieselben parse-Methoden für alle Zahlentypen
double d = Double.parseDouble("3.14");
long l = Long.parseLong("9999999999");
boolean istZahl = eingabe.matches("-?\\d+"); // Vorab-Prüfung per RegEx statt try/catch

parseInt/parseDouble/etc. gehören zu den häufigsten Quellen unbehandelter NumberFormatExceptions in Anfängerprogrammen, besonders bei direkter Verarbeitung von Nutzereingaben — ein Nutzer, der Buchstaben statt Zahlen eingibt, lässt das Programm sonst mit einer hässlichen Stacktrace-Meldung abstürzen, statt eine verständliche Fehlermeldung zu zeigen. Die Kombination aus vorheriger RegEx-Prüfung (matches("-?\\d+") erkennt, ob ein String nur aus optionalem Minus + Ziffern besteht) und anschließendem try/catch als zusätzliche Absicherung ist ein robustes, gängiges Muster für Eingabevalidierung.

parseXxx() vs. valueOf() — der feine Unterschied

Jede Wrapper-Klasse bietet beides, mit einem wichtigen Typunterschied: Integer.parseInt("42") liefert ein primitives int, Integer.valueOf("42") liefert ein Integer-Objekt. Bei automatischem Boxing spielt das in der Praxis oft keine Rolle, ist aber relevant, wenn explizit ein Objekt (z. B. für eine Collection wie List<Integer>) statt eines primitiven Werts gebraucht wird — valueOf() nutzt zudem einen internen Cache für kleine Zahlen (-128 bis 127), was ==-Vergleiche zwischen Integer-Objekten in diesem Bereich überraschend true liefern kann, während größere Zahlen das nicht tun.

Zahlen mit Formatierung ausgeben

Für die Rückrichtung (Zahl → lesbar formatierter Text) reicht reines String.valueOf() oft nicht — Tausendertrennzeichen, feste Nachkommastellen oder Währungsformate übernimmt NumberFormat bzw. String.format():

double preis = 1234567.891;
System.out.println(String.format("%,.2f", preis)); // "1,234,567.89" (US-Format)
 
NumberFormat deutsch = NumberFormat.getInstance(Locale.GERMANY);
System.out.println(deutsch.format(preis)); // "1.234.567,891" (deutsches Format: Punkt/Komma vertauscht)

Die Locale-Abhängigkeit ist ein häufiger Stolperstein in internationalisierten Anwendungen: dieselbe Zahl wird je nach Sprachraum mit unterschiedlichen Trenn- und Dezimalzeichen dargestellt, was bei fest programmierten Formatierungen zu Verwirrung führen kann, wenn die Zielgruppe wechselt.

Siehe auch: String Concatenation, Type Casting, Exceptions