Como faço para converter de int para String?

Estou trabalhando em um projeto em que todas as conversões de intpara Stringsão feitas assim:

int i = 5;
String strI = "" + i;

Eu não estou familiarizado com Java.

É prática habitual ou algo errado, como suponho?

Formas normais seriam Integer.toString(i)ou String.valueOf(i).

A concatenação funcionará, mas não é convencional e pode ser um mau cheiro, pois sugere que o autor não conhece os dois métodos acima (o que mais eles podem não saber?).

Java possui suporte especial para o operador + quando usado com strings (consulte a documentação ) que traduz o código no qual você postou:

StringBuilder sb = new StringBuilder();
sb.append("");
sb.append(i);
String strI = sb.toString();

em tempo de compilação. É um pouco menos eficiente ( sb.append()acaba chamando Integer.getChars(), o que Integer.toString()teria sido feito de qualquer maneira), mas funciona.

Para responder ao comentário de Grodriguez: ** Não, o compilador não otimiza a string vazia neste caso - veja:

simon@lucifer:~$ cat TestClass.java
public class TestClass {
  public static void main(String[] args) {
    int i = 5;
    String strI = "" + i;
  }
}
simon@lucifer:~$ javac TestClass.java && javap -c TestClass
Compiled from "TestClass.java"
public class TestClass extends java.lang.Object{
public TestClass();
  Code:
   0:    aload_0
   1:    invokespecial    #1; //Method java/lang/Object."<init>":()V
   4:    return

public static void main(java.lang.String[]);
  Code:
   0:    iconst_5
   1:    istore_1

Inicialize o StringBuilder:

   2:    new    #2; //class java/lang/StringBuilder
   5:    dup
   6:    invokespecial    #3; //Method java/lang/StringBuilder."<init>":()V

Anexe a sequência vazia:

   9:    ldc    #4; //String
   11:    invokevirtual    #5; //Method java/lang/StringBuilder.append:
(Ljava/lang/String;)Ljava/lang/StringBuilder;

Anexe o número inteiro:

   14:    iload_1
   15:    invokevirtual    #6; //Method java/lang/StringBuilder.append:
(I)Ljava/lang/StringBuilder;

Extraia a sequência final:

   18:    invokevirtual    #7; //Method java/lang/StringBuilder.toString:
()Ljava/lang/String;
   21:    astore_2
   22:    return
}

Há uma proposta e trabalho em andamento para alterar esse comportamento, direcionado para o JDK 9.

É aceitável, mas nunca escrevi nada assim. Eu preferiria isso:

String strI = Integer.toString(i);

Não é um bom caminho.

Ao fazer a conversão de int para string, isso deve ser usado:

int i = 5;
String strI = String.valueOf(i);

Não é apenas a otimização ¹ . Eu não gosto

"" + i

porque não expressa o que realmente quero fazer ² .

Não quero acrescentar um número inteiro a uma string (vazia). Eu quero converter um número inteiro em string:

Integer.toString(i)

Ou, não é o meu preferido, mas ainda melhor que a concatenação, obtenha uma representação em string de um objeto (inteiro):

String.valueOf(i)

^{1. Para código que é chamado com muita frequência, como em loops, a otimização com certeza também é um ponto para não usar concatenação .}

^{2. isso não é válido para o uso de concatenação real, como em System.out.println("Index: " + i); ou String id = "ID" + i;}

Muitos cursos introdutórios da Universidade parecem ensinar esse estilo, por duas razões (na minha experiência):

• Não requer compreensão de classes ou métodos. Geralmente, isso é ensinado muito antes da palavra "classe" ser mencionada - nem mesmo de chamadas de método. Então, usar algo como String.valueOf(…)isso confundiria os alunos.

• É uma ilustração de “sobrecarga de operador” - na verdade, este foi vendido para nós como o operador sobrecarregado idiomática (pequena maravilha aqui, já que Java não permite personalizado sobrecarga de operador).

Portanto, pode nascer da necessidade didática (embora eu argumente que isso é apenas um mau ensino) ou ser usado para ilustrar um princípio que, de outra forma, é bastante difícil de demonstrar em Java.

A expressão

"" + i

leva à conversão de stringi em tempo de execução. O tipo geral da expressão é String. ié primeiro convertido em um Integerobjeto ( new Integer(i)) e depois String.valueOf(Object obj)chamado. Então é equivalente a

"" + String.valueOf(new Integer(i));

Obviamente, isso é um pouco menos eficiente do que apenas chamar, String.valueOf(new Integer(i))que produzirá o mesmo resultado.

A vantagem ""+ié que a digitação é mais fácil / rápida e algumas pessoas podem pensar, que é mais fácil de ler. Não é um cheiro de código , pois não indica nenhum problema mais profundo.

(Referência: JLS 15.8.1 )

Pessoalmente, não vejo nada de ruim nesse código.

É bastante útil quando você deseja registrar um valor int, e o criador de log aceita apenas uma string. Eu diria que essa conversão é conveniente quando você precisa chamar um método que aceita uma String, mas você tem um valor int.

Quanto à escolha entre Integer.toStringou String.valueOf, é tudo uma questão de gosto.
... E internamente, String.valueOfo Integer.toStringmétodo é chamado . :)

A outra maneira pela qual estou ciente é da Integerclasse:

Integer.toString(int n);
Integer.toString(int n, int radix);

Um exemplo concreto (embora eu ache que você não precisa de nenhum):

String five = Integer.toString(5); // returns "5"

Também funciona para outros tipos primitivos, por exemplo Double.toString.

Veja aqui para mais detalhes.

Essa técnica foi ensinada em uma aula de introdução à Java em nível de graduação que fiz há mais de uma década. No entanto, devo observar que, IIRC, ainda não tínhamos chegado aos métodos das classes String e Inteiro.

A técnica é simples e rápida de digitar. Se tudo o que estou fazendo for imprimir algo, eu o usarei (por exemplo System.out.println("" + i);,. No entanto, acho que não é a melhor maneira de fazer uma conversão, pois é preciso um segundo para perceber o que está acontecendo quando está sendo usado. Além disso, se o desempenho é uma preocupação, parece mais lento (mais abaixo, bem como em outras respostas).

Pessoalmente, prefiro Integer.toString (), pois é óbvio o que está acontecendo. String.valueOf () seria minha segunda opção, pois parece confuso (veja os comentários após a resposta de darioo).

Apenas para sorrisos :) Eu escrevi aulas para testar as três técnicas: "" + i, Integer.toString e String.ValueOf. Cada teste acabou de converter as entradas de 1 para 10000 em Strings. Em seguida, executei cada um pelo comando time do Linux cinco vezes. Integer.toString () foi um pouco mais rápido que String.valueOf () uma vez, eles empataram três vezes e String.valueOf () foi mais rápido uma vez; no entanto, a diferença nunca foi superior a alguns milissegundos.

A técnica "" + i foi mais lenta que ambas em todos os testes, exceto um, quando foi 1 milissegundo mais rápido que Integer.toString () e 1 milissegundo mais lento que String.valueOf () (obviamente no mesmo teste em que String.valueOf () foi mais rápido que Integer.toString ()). Embora normalmente fosse apenas alguns milissegundos mais lento, houve um teste em que foi cerca de 50 milissegundos mais lento. YMMV .

Existem várias maneiras de converter para Strings:

StringBuilder string = string.append(i).toString();
String string = String.valueOf(i);
String string = Integer.toString(i);

Depende de como você deseja usar sua String. Isso pode ajudar:

String total =  Integer.toString(123) + Double.toString(456.789);

O mesmo vale para SimonJ. Eu realmente não gosto do idioma "" + i. Se você disser String.valueOf (i), Java converte o número inteiro em uma sequência e retorna o resultado. Se você disser "" + i, Java cria um objeto StringBuilder, anexa uma string vazia a ele, converte o número inteiro em uma string, anexa ao StringBuilder e, em seguida, converte o StringBuilder em uma String. São muitas etapas extras. Suponho que se você fizer isso uma vez em um grande programa, não é grande coisa. Mas se você está fazendo isso o tempo todo, está fazendo o computador fazer um monte de trabalho extra e criando todos esses objetos extras que precisam ser limpos. Não quero ser fanático por micro-otimização, mas também não quero ser inútil.

String strI = String.valueOf(i);

String string = Integer.toString(i);

Ambas as formas estão corretas.

Existem várias maneiras de converter um número inteiro em uma string:

1)

Integer.toString(10);

2)

 String hundred = String.valueOf(100); // You can pass an int constant
 int ten = 10;
 String ten = String.valueOf(ten)

3)

String thousand = "" + 1000; // String concatenation

4)

String million = String.format("%d", 1000000)

Existem três maneiras de converter para Strings

1. String string = "" + i;
2. String string = String.valueOf(i);
3. String string = Integer.toString(i);

Usar "" + i é a maneira mais curta e simples de converter um número em uma string. Não é o mais eficiente, mas é o IMHO mais claro e isso geralmente é mais importante. Quanto mais simples o código, menor a probabilidade de você cometer um erro.

Pessoalmente, acho que "" + i parece que o pôster original da pergunta indica "fedido". Eu usei muitas linguagens OO além do Java. Se a sintaxe pretendesse ser apropriada, o Java apenas interpretaria o i sozinho, sem precisar que o "" desejado fosse convertido em uma string e o faria, pois o tipo de destino é inequívoco e apenas um único valor seria fornecido à direita . O outro parece um "truque" para enganar o compilador, algo ruim quando diferentes versões do Javac feitas por outros fabricantes ou de outras plataformas são consideradas se o código precisar ser portado. Caramba, meu dinheiro deve gostar de muitos outros OOLs apenas faça um Typecast: (String) i. winks

Dada a minha maneira de aprender e para facilitar a compreensão dessa construção ao ler rapidamente o código de outros, voto no método Integer.toString (i). Esquecendo um ns ou dois na maneira como o Java implementa as coisas em segundo plano vs. String.valueOf (i) esse método parece certo para mim e diz exatamente o que está acontecendo: eu tenho e Inteiro e desejo que ele seja convertido em uma String.

Um bom argumento feito algumas vezes é que talvez apenas usar StringBuilder na frente seja uma boa resposta para criar Strings misturadas de texto e ints ou outros objetos, já que é isso que será usado de qualquer maneira, em segundo plano, certo?

Apenas meus dois centavos jogados no gatinho já bem pago das respostas para a pergunta do Mans ... sorri

EDITAR PARA MINHA PRÓPRIA RESPOSTA APÓS ALGUMAS REFLEXÕES:

Ok, ok, eu estava pensando nisso um pouco mais e String.valueOf (i) também é perfeitamente bom, assim também diz: Eu quero uma String que represente o valor de um Inteiro. lol, o inglês é muito mais difícil de analisar do que o Java! Mas deixo o resto da minha resposta / comentário ... Sempre fui ensinado a usar o nível mais baixo de uma cadeia de métodos / funções, se possível, e ainda mantém a legibilidade, portanto, se String.valueOf chama Integer.toString, por que usar uma laranja inteira se você vai descascar de qualquer maneira, Hmmm?

Para esclarecer meu comentário sobre o StringBuilder, eu construo muitas seqüências de caracteres com combinações de texto e int literalmente, e elas acabam sendo longas e feias com chamadas para as rotinas mencionadas acima, embutidas entre os +, assim parece-me que elas se tornam Objetos SB de qualquer maneira e o método append tem sobrecargas, pode ser mais limpo seguir em frente e usá-lo ... Então, acho que estou com até 5 centavos de dólar neste agora, não é? ri muito...

usar Integer.toString(tmpInt).trim();

Experimente a digitação simples

char c = (char) i;