Cómo convertir int a String en Java

Convertir un int en un String es una de las conversiones más comunes en Java — la necesitas cuando registras un número, construyes un mensaje o escribes un valor en un archivo. El JDK ofrece varias formas de hacerlo y todas producen el mismo texto. Este capítulo muestra las opciones idiomáticas y cuándo usar cada una.

Integer.toString — la llamada directa

La forma más clara y explícita es Integer.toString(int). Dice exactamente lo que hace y devuelve el texto decimal del número:

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

Este es el método al que String.valueOf y la concatenación terminan llamando internamente, por lo que es la conversión canónica. Los valores negativos conservan su signo (Integer.toString(-7) devuelve "-7"), y el resultado nunca es null.

String.valueOf — seguro con null y sobrecargado

String.valueOf está sobrecargado para cada tipo primitivo, por lo que la misma llamada funciona para int, long, double, boolean y char:

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

Para un int simplemente delega en Integer.toString, por lo que la salida es idéntica. Muchos desarrolladores lo prefieren porque un único nombre cubre todos los primitivos y es la elección convencional al convertir una referencia de objeto que podría ser null (devuelve "null" en lugar de lanzar una excepción).

Concatenación de String — rápida pero cuidado con el costo

Añadir un int a una cadena vacía fuerza una conversión:

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

Es conciso y está bien para un uso puntual, pero el compilador lo convierte en una operación con StringBuilder. Dentro de un bucle, los repetidos "" + n crean muchos objetos desechables; prefiere Integer.toString o un único StringBuilder en esos casos.

String.format y conversiones de base

Cuando necesitas relleno, un signo o una base no decimal, usa String.format o los métodos de Integer que admiten base:

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

Aquí se comparan las opciones más habituales:

Enfoque	Mejor para	Nota
`Integer.toString(n)`	Texto decimal simple	Canónico; nunca `null`
`String.valueOf(n)`	Un nombre para todos los primitivos	Delega en `Integer.toString`
`"" + n`	Uso rápido en línea	Evitar en bucles ajustados
`String.format("%05d", n)`	Relleno / formato	Sensible a locale, más lento
`Integer.toString(n, radix)`	Texto hex, binario, octal	Base 2–36

Un ejemplo práctico

Este programa ejecuta cada enfoque con el mismo valor, confirma que los tres métodos comunes producen cadenas iguales y muestra el resultado de formato y base.

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

Lo que se puede extraer de la ejecución:

Integer.toString(-42), String.valueOf(-42) y "" + (-42) imprimen todos -42 — las tres formas comunes son intercambiables para texto decimal simple.
La línea equal? imprime true, lo que demuestra que los tres resultados son idénticos carácter a carácter, porque String.valueOf y la concatenación ambas pasan por Integer.toString.
El signo negativo sobrevive a la conversión, y la cadena resultante tiene longitud 3 (-, 4, 2) — el menos cuenta como un carácter.
String.format("%05d", 42) imprime 00042, mostrando cómo la directiva %05d rellena con ceros hasta un ancho mínimo de cinco.
Integer.toBinaryString(255) imprime 11111111 e Integer.toString(255, 16) imprime ff, lo que demuestra que un int puede representarse en cualquier base, no solo decimal.

Práctica

¿Qué llamada convierte un int a su String decimal simple y es el método canónico al que String.valueOf(int) delega internamente?

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

Capítulos relacionados

Convertir un String a int — la operación inversa, con Integer.parseInt y manejo de errores.
Formato de strings en Java — más sobre las directivas de String.format como %05d, %x y %,d.
Concatenación de strings en Java — por qué "" + n se convierte en un StringBuilder y cuándo importa eso.
StringBuilder — la forma eficiente de ensamblar muchos números en una sola cadena dentro de un bucle.