Come convertire int in String in Java

Trasformare un int in una String è una delle conversioni più comuni in Java — serve ogni volta che si registra un numero, si costruisce un messaggio o si scrive un valore su file. Il JDK offre diversi modi per farlo, e producono tutti lo stesso testo. Questo capitolo mostra le opzioni idiomatiche e quando utilizzare ciascuna.

Integer.toString — la chiamata diretta

Il modo più chiaro ed esplicito è Integer.toString(int). Dice esattamente cosa fa e restituisce il testo decimale del numero:

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

Questo è il metodo che String.valueOf e la concatenazione finiscono entrambi per chiamare internamente, quindi è la conversione canonica. I valori negativi mantengono il loro segno (Integer.toString(-7) restituisce "-7"), e il risultato non è mai null.

String.valueOf — null-safe e sovraccaricato

String.valueOf è sovraccaricato per ogni tipo primitivo, quindi la stessa chiamata funziona per int, long, double, boolean e char:

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

Per un int delega semplicemente a Integer.toString, quindi l'output è identico. Molti sviluppatori lo preferiscono perché un unico nome copre tutti i primitivi ed è la scelta convenzionale quando si converte un riferimento a oggetto che potrebbe essere null (restituisce "null" invece di lanciare un'eccezione).

Concatenazione di stringhe — rapida ma attenzione al costo

Aggiungere un int a una stringa vuota forza una conversione:

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

È concisa e va bene per un uso occasionale, ma il compilatore la trasforma in un'operazione StringBuilder. All'interno di un ciclo, ripetuti "" + n creano molti oggetti temporanei; preferire Integer.toString o un singolo StringBuilder in quel caso.

String.format e conversioni di base numerica

Quando si ha bisogno di spaziatura, un segno o una base non decimale, usare String.format o i metodi Integer che supportano la radice:

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

Ecco come si confrontano le opzioni più comuni:

Approccio	Ideale per	Nota
`Integer.toString(n)`	Testo decimale semplice	Canonico; mai `null`
`String.valueOf(n)`	Un solo nome per tutti i primitivi	Delega a `Integer.toString`
`"" + n`	Uso rapido inline	Evitare nei cicli stretti
`String.format("%05d", n)`	Spaziatura / formattazione	Sensibile alla locale, più lento
`Integer.toString(n, radix)`	Testo esadecimale, binario, ottale	Radice 2–36

Un esempio pratico

Questo programma esegue ogni approccio sullo stesso valore, conferma che i tre metodi comuni producono stringhe uguali e mostra la formattazione e l'output con radici diverse.

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());
  }
}

Cosa trarre dall'esecuzione:

Integer.toString(-42), String.valueOf(-42) e "" + (-42) stampano tutti -42 — i tre modi comuni sono intercambiabili per il testo decimale semplice.
La riga equal? stampa true, dimostrando che i tre risultati sono carattere per carattere identici, perché String.valueOf e la concatenazione instradano entrambe attraverso Integer.toString.
Il segno negativo sopravvive alla conversione, e la stringa risultante ha lunghezza 3 (-, 4, 2) — il meno conta come carattere.
String.format("%05d", 42) stampa 00042, mostrando come la direttiva %05d aggiunga zeri fino a una larghezza minima di cinque.
Integer.toBinaryString(255) stampa 11111111 e Integer.toString(255, 16) stampa ff, dimostrando che un int può essere rappresentato in qualsiasi base, non solo decimale.

Esercitazione

Pratica

Quale chiamata converte un int nella sua forma String decimale semplice ed è il metodo canonico a cui String.valueOf(int) delega internamente?

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

Capitoli correlati

Convertire una String in int — l'operazione inversa, con Integer.parseInt e la gestione degli errori.
Formattazione delle stringhe Java — approfondimento sulle direttive String.format come %05d, %x e %,d.
Concatenazione di stringhe Java — perché "" + n diventa un StringBuilder e quando questo è rilevante.
StringBuilder — il modo efficiente per assemblare molti numeri in un'unica stringa all'interno di un ciclo.