Como Converter int para String em Java

Converter um int em um String é uma das conversões mais comuns em Java — você precisa disso sempre que registra um número, constrói uma mensagem ou escreve um valor em um arquivo. O JDK oferece várias formas de fazer isso, e todas produzem o mesmo texto. Este capítulo mostra as opções idiomáticas e quando usar cada uma.

Integer.toString — a chamada direta

A forma mais clara e explícita é Integer.toString(int). Ela diz exatamente o que faz e retorna o texto decimal do número:

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

Este é o método que String.valueOf e a concatenação acabam chamando internamente, sendo portanto a conversão canônica. Valores negativos mantêm seu sinal (Integer.toString(-7) retorna "-7"), e o resultado nunca é null.

String.valueOf — seguro para null e sobrecarregado

String.valueOf é sobrecarregado para todos os tipos primitivos, então a mesma chamada funciona para int, long, double, boolean e char:

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

Para um int, ele simplesmente delega para Integer.toString, então a saída é idêntica. Muitos desenvolvedores o preferem porque um único nome cobre todos os primitivos e é a escolha convencional ao converter uma referência de objeto que pode ser null (retorna "null" em vez de lançar uma exceção).

Concatenação de strings — rápido, mas atenção ao custo

Anexar um int a uma string vazia força uma conversão:

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

É conciso e adequado para um uso pontual, mas o compilador transforma isso em uma operação com StringBuilder. Dentro de um loop, repetir "" + n cria muitos objetos descartáveis; prefira Integer.toString ou um único StringBuilder nesses casos.

String.format e conversões de base

Quando você precisa de preenchimento, um sinal ou uma base não decimal, use String.format ou os métodos Integer com suporte a base:

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

Veja como as opções mais comuns se comparam:

Abordagem	Melhor para	Observação
`Integer.toString(n)`	Texto decimal simples	Canônico; nunca `null`
`String.valueOf(n)`	Um único nome para todos os primitivos	Delega para `Integer.toString`
`"" + n`	Uso rápido inline	Evite em loops intensos
`String.format("%05d", n)`	Preenchimento / formatação	Sensível ao locale, mais lento
`Integer.toString(n, radix)`	Texto em hex, binário, octal	Base 2–36

Um exemplo prático

Este programa executa todas as abordagens sobre o mesmo valor, confirma que os três métodos comuns produzem strings iguais e mostra a saída de formatação e 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());
  }
}

O que extrair da execução:

Integer.toString(-42), String.valueOf(-42) e "" + (-42) todos imprimem -42 — as três formas comuns são intercambiáveis para texto decimal simples.
A linha equal? imprime true, provando que os três resultados são idênticos caractere por caractere, pois String.valueOf e a concatenação passam por Integer.toString.
O sinal negativo sobrevive à conversão, e a string resultante tem comprimento 3 (-, 4, 2) — o sinal de menos conta como um caractere.
String.format("%05d", 42) imprime 00042, mostrando como a diretiva %05d preenche com zeros até uma largura mínima de cinco.
Integer.toBinaryString(255) imprime 11111111 e Integer.toString(255, 16) imprime ff, demonstrando que um int pode ser representado em qualquer base, não apenas decimal.

Prática

Qual chamada converte um int para sua forma de String decimal simples e é o método canônico para o qual String.valueOf(int) delega internamente?

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

Capítulos relacionados

Converter uma String em int — a operação inversa, com Integer.parseInt e tratamento de erros.
Formatação de strings em Java — mais sobre as diretivas de String.format como %05d, %x e %,d.
Concatenação de strings em Java — por que "" + n se torna um StringBuilder e quando isso importa.
StringBuilder — a forma eficiente de montar muitos números em uma única string dentro de um loop.