int in String umwandeln in Java

Einen int in einen String zu verwandeln ist eine der häufigsten Konvertierungen in Java — man braucht sie immer dann, wenn man eine Zahl protokolliert, eine Nachricht zusammenstellt oder einen Wert in eine Datei schreibt. Das JDK bietet dafür mehrere Möglichkeiten, und alle erzeugen denselben Text. Dieses Kapitel zeigt die idiomatischen Optionen und wann man welche verwenden sollte.

Integer.toString — der direkte Aufruf

Die klarste und expliziteste Methode ist Integer.toString(int). Sie sagt genau das, was sie tut, und gibt den Dezimaltext der Zahl zurück:

int n = 256;
String s = Integer.toString(n); // "256"

Das ist die Methode, die String.valueOf und Verkettung intern beide aufrufen, und damit die kanonische Konvertierung. Negative Werte behalten ihr Vorzeichen (Integer.toString(-7) gibt "-7" zurück), und das Ergebnis ist niemals null.

String.valueOf — null-sicher und überladen

String.valueOf ist für jeden primitiven Typ überladen, sodass derselbe Aufruf für int, long, double, boolean und char funktioniert:

int n = 256;
String s = String.valueOf(n); // "256"

Für einen int delegiert sie einfach an Integer.toString, das Ergebnis ist also identisch. Viele Entwickler bevorzugen sie, weil ein einziger Name alle primitiven Typen abdeckt, und sie ist die übliche Wahl beim Konvertieren einer Objektreferenz, die null sein könnte (sie gibt "null" zurück, anstatt eine Ausnahme zu werfen).

String-Verkettung — schnell, aber Vorsicht bei den Kosten

Das Anhängen eines int an einen leeren String erzwingt eine Konvertierung:

int n = 256;
String s = "" + n; // "256"

Das ist prägnant und für einen Einzelfall in Ordnung, aber der Compiler wandelt es in eine StringBuilder-Operation um. Innerhalb einer Schleife erzeugt das wiederholte "" + n viele kurzlebige Objekte; bevorzuge dort Integer.toString oder einen einzelnen StringBuilder.

String.format und Radix-Konvertierungen

Wenn Auffüllung, ein Vorzeichen oder eine nicht-dezimale Basis benötigt wird, verwende String.format oder die Radix-bewussten Integer-Methoden:

String padded = String.format("%05d", 42);   // "00042"
String hex    = Integer.toString(255, 16);    // "ff"
String binary = Integer.toBinaryString(255);  // "11111111"

Hier ein Vergleich der gängigen Optionen:

Ansatz	Am besten für	Hinweis
`Integer.toString(n)`	Einfacher Dezimaltext	Kanonisch; niemals `null`
`String.valueOf(n)`	Ein Name für alle primitiven Typen	Delegiert an `Integer.toString`
`"" + n`	Schnelle Inline-Verwendung	In engen Schleifen vermeiden
`String.format("%05d", n)`	Auffüllung / Formatierung	Locale-bewusst, langsamer
`Integer.toString(n, radix)`	Hex-, Binär-, Oktaltext	Radix 2–36

Ein durchgearbeitetes Beispiel

Dieses Programm führt jeden Ansatz auf demselben Wert aus, bestätigt, dass die drei gebräuchlichen Methoden gleiche Strings erzeugen, und zeigt Formatierungs- und Radix-Ausgabe.

java— editable, runs on the server

public class IntToStringDemo {
  public static void main(String[] args) {
    int n = -42;

// 1. Integer.toString — the most direct, intent-revealing call.
    String a = Integer.toString(n);

// 2. String.valueOf — null-safe, overloaded for every primitive.
    String b = String.valueOf(n);

// 3. Concatenation — quick, but builds a StringBuilder behind the scenes.
    String c = "" + n;

// 4. String.format — when you need padding or a sign.
    String d = String.format("%05d", 42);

// 5. A different radix: int to its binary / hex text.
    String bin = Integer.toBinaryString(255);
    String hex = Integer.toString(255, 16);

System.out.println("Integer.toString : " + a);
    System.out.println("String.valueOf   : " + b);
    System.out.println("concatenation    : " + c);
    System.out.println("equal?           : " + (a.equals(b) && b.equals(c)));
    System.out.println("formatted (%05d) : " + d);
    System.out.println("255 in binary    : " + bin);
    System.out.println("255 in hex       : " + hex);
    System.out.println("length of \"" + a + "\" : " + a.length());
  }
}

Was aus der Ausgabe zu entnehmen ist:

Integer.toString(-42), String.valueOf(-42) und "" + (-42) geben alle -42 aus — die drei gebräuchlichen Methoden sind für einfachen Dezimaltext austauschbar.
Die Zeile equal? gibt true aus und beweist, dass die drei Ergebnisse Zeichen für Zeichen identisch sind, weil String.valueOf und Verkettung beide über Integer.toString laufen.
Das negative Vorzeichen bleibt bei der Konvertierung erhalten, und der resultierende String hat die Länge 3 (-, 4, 2) — das Minuszeichen zählt als Zeichen.
String.format("%05d", 42) gibt 00042 aus und zeigt, wie die Direktive %05d auf eine Mindestbreite von fünf Stellen mit Nullen auffüllt.
Integer.toBinaryString(255) gibt 11111111 aus und Integer.toString(255, 16) gibt ff aus, was zeigt, dass ein int in jeder Basis dargestellt werden kann, nicht nur dezimal.

Übung

Welcher Aufruf wandelt einen int in seinen einfachen dezimalen String um und ist die kanonische Methode, an die String.valueOf(int) intern delegiert?

Integer.toString(n)Integer.parseInt(n)new Integer(n)String.toString(n)

Wie man in Java einen int in einen String umwandelt