Convertir int en String en Java

Transformer un int en String est l'une des conversions les plus courantes en Java — vous en avez besoin dès lors que vous journalisez un nombre, construisez un message ou écrivez une valeur dans un fichier. Le JDK propose plusieurs façons de le faire, et elles produisent toutes le même texte. Ce chapitre présente les options idiomatiques et quand utiliser chacune d'elles.

Integer.toString — l'appel direct

La façon la plus claire et la plus explicite est Integer.toString(int). Elle dit exactement ce qu'elle fait et retourne le texte décimal du nombre :

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

C'est la méthode que String.valueOf et la concaténation appellent toutes deux en interne, donc c'est la conversion canonique. Les valeurs négatives conservent leur signe (Integer.toString(-7) retourne "-7"), et le résultat n'est jamais null.

String.valueOf — sûr pour null et surchargé

String.valueOf est surchargé pour chaque type primitif, donc le même appel fonctionne pour int, long, double, boolean et char :

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

Pour un int, il délègue simplement à Integer.toString, donc le résultat est identique. De nombreux développeurs le préfèrent car le même nom couvre tous les primitifs, et c'est le choix conventionnel lorsqu'on convertit une référence objet qui pourrait être null (il retourne "null" au lieu de lever une exception).

Concaténation de String — rapide, mais attention au coût

Ajouter un int à une chaîne vide force une conversion :

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

C'est concis et acceptable pour un usage ponctuel, mais le compilateur le transforme en opération StringBuilder. Dans une boucle, des répétitions de "" + n créent de nombreux objets temporaires ; préférez Integer.toString ou un unique StringBuilder dans ce cas.

String.format et conversions de base

Lorsque vous avez besoin d'un rembourrage, d'un signe ou d'une base non décimale, utilisez String.format ou les méthodes Integer prenant en charge la base :

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

Voici comment se comparent les options courantes :

Approche	Idéal pour	Remarque
`Integer.toString(n)`	Texte décimal simple	Canonique ; jamais `null`
`String.valueOf(n)`	Un seul nom pour tous les primitifs	Délègue à `Integer.toString`
`"" + n`	Usage inline rapide	À éviter dans les boucles serrées
`String.format("%05d", n)`	Rembourrage / formatage	Dépend de la locale, plus lent
`Integer.toString(n, radix)`	Texte hex, binaire, octal	Base 2–36

Un exemple concret

Ce programme exécute chaque approche sur la même valeur, confirme que les trois méthodes courantes produisent des chaînes égales, et montre le résultat du formatage et des bases.

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

Ce que l'on retient de l'exécution :

Integer.toString(-42), String.valueOf(-42) et "" + (-42) affichent tous -42 — les trois façons courantes sont interchangeables pour le texte décimal simple.
La ligne equal? affiche true, prouvant que les trois résultats sont identiques caractère par caractère, car String.valueOf et la concaténation passent toutes deux par Integer.toString.
Le signe négatif est conservé lors de la conversion, et la chaîne résultante a une longueur de 3 (-, 4, 2) — le moins compte comme un caractère.
String.format("%05d", 42) affiche 00042, montrant comment la directive %05d remplit avec des zéros jusqu'à une largeur minimale de cinq.
Integer.toBinaryString(255) affiche 11111111 et Integer.toString(255, 16) affiche ff, démontrant qu'un int peut être représenté dans n'importe quelle base, pas seulement en décimal.

Pratique

Quel appel convertit un int en sa forme String décimale simple et est la méthode canonique vers laquelle String.valueOf(int) délègue en interne ?

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

Chapitres connexes

Convertir une String en int — l'opération inverse, avec Integer.parseInt et la gestion des erreurs.
Formatage des strings Java — pour en savoir plus sur les directives String.format comme %05d, %x et %,d.
Concaténation de strings Java — pourquoi "" + n devient un StringBuilder et quand cela est important.
StringBuilder — la façon efficace d'assembler de nombreux nombres en une seule chaîne dans une boucle.