Como faço para converter de int para String?

745

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?

Denis Palnitsky
fonte
47
O jeito "bobo, fácil" é string = "" + inteiro;
Fattie
1
belo documento: [ javarevisited.blogspot.de/2011/08/… exemplo
Narayan Yerrabachu
2
Eu apenas quis dizer que é uma maneira "rápida e simples" de fazer isso. é um pouco bobo, mas funciona!
Gordo
1
Um colega meu fez Integer.valueOf(i).toString(). Ele deve ter gostado de objetos. Embora exponha claramente sua intenção, é um pouco longo para o meu gosto.
precisa saber é
5
Você só precisa de 45 linhas de código e implementa 7 interfaces para isso.
Ska

Respostas:

958

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
}

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

SimonJ
fonte
9
e o compilador jit na jvm? :-) javac não faz nenhuma otimização sofisticada.
Peter Štibraný
5
Quem sabe :) o javac otimiza esse tipo de expressão quando literais numéricos são usados ​​(no entanto, "" + 5torna-se "5").
Simonj
5
Sim, mas por que você faria em "" + 5vez de apenas "5"?
Grungondola
3
Agradável! +1 para o que mais eles podem não saber?
17006
2
A "" + integerabordagem é usada em um dos tutoriais oficiais do oracle .
Tomasz Nocoń
252

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

String strI = Integer.toString(i);
duffymo
fonte
101
Eu prefiro a abordagem String.valueOf, pois você pode usar exatamente a mesma chamada para qualquer tipo.
quer
1
NumberFormatter seria uma melhor abordagem
Kasturi
Uma boa resposta, Kasturi. Eu o publicaria como algo mais que um comentário.
Duffymo
2
Desculpe pela minha ignorância, mas isso não usaria a cultura atual? Estou vindo formar um plano de fundo. NET BTW.
Г И І О
3
Para um número inteiro, não há itens específicos da cultura sendo usados ​​por padrão (não há separador decimal ou milhares). É para isso que NumberFormatterserve. Você pode usar formatos como NumberFormat.getInstance(Locale.FRENCH).
Kat
111

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);
darioo
fonte
7
1. Você pede a string vazia; 2. Você pede concatenação; 3. como você não possui uma string, você finalmente converterá seu int em string. A solução do daridoo evita os primeiros passos.
Nicolas
é int iencaixotado em um Integerantes de ser adicionado ao String strI?
Kevin Meredith
1
@KevinMeredith, não, não. Você estaria realmente chamando StringBuilder.append(int)(e StringBuildertem um appendmétodo para todos os tipos primitivos).
Kat
60

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

"" + i

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

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;

user85421
fonte
3
As pessoas que estão falando sobre desempenho nesse contexto são uma distração. Muito, muito, muito, muito, muito mais importante é a legibilidade .
Brian Goetz
23

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.

Konrad Rudolph
fonte
2
acho que, pelo contrário, construções como "" + eu confundiria novatos. E também é um estilo ruim para o resto de suas vidas.
Konstantin Zyubin
15

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 )

Andreas Dolk
fonte
3
Sua declaração "equivalente" não é equivalente. Mesmo se chamar String.valueOfboxe necessário i(não, pois há uma sobrecarga que aceita um int), ele não usaria new Integer(i), usaria Integer.valueOf(i). Mas isso realmente não faz nada disso. Ele faz new StringBuilder().append("").append(i).toString(), como notas de resposta do Simonj. StringBuilder tem sua própria lógica para transformar um int primitivo iem um String.
Mark Peters
4
A parte sobre o cheiro do código está certa; cheiro de código é o termo errado aqui. Então eu vou tirar o voto negativo.
Mark Peters
Parece ineficiente fazê-lo com "" + i. Apenas Integer.toString ou String.valueOf simples é recomendado. Veja javadevnotes.com/java-integer-to-string-examples
JavaDev
14

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 . :)

ksu
fonte
12

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.

zneak
fonte
9

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 .

GreenMatt
fonte
1
Não se esqueça de levar o JIT em consideração - as primeiras conversões serão muito mais lentas e distorcerão os tempos. No meu MacBook, a concatenação leva ~ 20ns a mais do que os outros dois métodos (que ambos levam ~ 50ns por conversão); portanto, as diferenças que você viu na ordem dos ms provavelmente se devem a erros aleatórios (agendamento, interrupções etc.).
precisa saber é o seguinte
6

Existem várias maneiras de converter para Strings:

StringBuilder string = string.append(i).toString();
String string = String.valueOf(i);
String string = Integer.toString(i);
Shailej Shimpi
fonte
StringBuilder string = string.append (i) .toString (); ... Hum, então é o StringBuilder, ou um String? Alguma bagunça aqui ...
Franta
6

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

String total =  Integer.toString(123) + Double.toString(456.789);
Niyuhire Justine
fonte
5

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.

Jay
fonte
5
String strI = String.valueOf(i);

String string = Integer.toString(i);

Ambas as formas estão corretas.

Shailej Shimpi
fonte
5

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)
Hoque MD Zahidul
fonte
1
String.format ("% d", 1000000) ... Isso não é realmente Int >> Conversão de String, é sim String >> String processando aqui, apesar de sobrecarregado. Então, eu não recomendo isso. Definitivamente, não para fins de apenas uma conversão.
Franta
5

Existem três maneiras de converter para Strings

  1. String string = "" + i;
  2. String string = String.valueOf(i);
  3. String string = Integer.toString(i);
Vihaan Verma
fonte
1
Você esqueceu: String.format("%d", i).
Brian Goetz
3

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.

Peter Lawrey
fonte
2
Como alguém cometeria um erro ao chamar String.valueOf ou Integer.toString?
Eva
1
Eu me deparei com alguns usos não ideais de String.valueOf (), mas não consigo me lembrar deles agora. Enquanto a saída foi correta era menos eficiente do que""+i
Peter Lawrey
2

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...

David
fonte
-1

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

Karan Chunara
fonte
Realmente não há situação em trim()que possa ser útil aqui.
Dorian Gray
-5

Experimente a digitação simples

char c = (char) i;
Bilal Haider
fonte
3
Essa não é uma boa maneira de converter um int em uma string. Na verdade, você não está convertendo um int em uma string, está convertendo um int em um caractere. Isso interpretará o int como um código de caractere ASCII e fornecerá esse caractere. É perigoso (valores negativos, etc.) e, no geral, simplesmente errado.
Nepoxx
Por favor, limpe a pergunta acima, char e String são diferentes ...!
mas isso funciona (ASCII charset "offset"):char c = (char) (i + 48);
electrobabe