¿Cómo convierto de int a String?

Estoy trabajando en un proyecto donde todas las conversiones de inta Stringse hacen así:

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

No estoy familiarizado con Java.

¿Es esta práctica habitual o hay algo mal, como supongo?

Las formas normales serían Integer.toString(i)o String.valueOf(i).

La concatenación funcionará, pero no es convencional y podría ser un mal olor, ya que sugiere que el autor no conoce los dos métodos anteriores (¿qué más podrían no saber?).

Java tiene soporte especial para el operador + cuando se usa con cadenas (consulte la documentación ) que traduce el código publicado en:

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

en tiempo de compilación. Es un poco menos eficiente ( sb.append()termina llamando Integer.getChars(), que es lo que Integer.toString()habría hecho de todos modos), pero funciona.

Para responder el comentario de Grodriguez: ** No, el compilador no optimiza la cadena vacía en este caso - mira:

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

Inicialice el StringBuilder:

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

Agregue la cadena vacía:

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

Añadir el número entero:

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

Extraer la cadena final:

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

Hay una propuesta y un trabajo en curso para cambiar este comportamiento, dirigido a JDK 9.

Es aceptable, pero nunca he escrito algo así. Prefiero esto:

String strI = Integer.toString(i);

No es un buen camino.

Al hacer la conversión de int a string, esto debe usarse:

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

No es solo la optimización ¹ . No me gusta

"" + i

porque no expresa lo que realmente quiero hacer ² .

No quiero agregar un número entero a una cadena (vacía). Quiero convertir un entero en una cadena:

Integer.toString(i)

O, no es lo que prefiero, pero aún mejor que la concatenación, obtenga una representación de cadena de un objeto (entero):

String.valueOf(i)

^{1. Para el código que se llama con mucha frecuencia, como en los bucles, la optimización segura también es un punto para no usar la concatenación .}

^{2. esto no es válido para el uso de concatenación real como en System.out.println("Index: " + i); o String id = "ID" + i;}

Muchos cursos universitarios introductorios parecen enseñar este estilo, por dos razones (en mi experiencia):

• No requiere comprensión de clases o métodos. Por lo general, esto se enseña mucho antes de que se mencione la palabra "clase", ni siquiera las llamadas a métodos. Así que usar algo así String.valueOf(…)confundiría a los estudiantes.

• Es una ilustración de "sobrecarga del operador"; de hecho, esto se nos vendió como el operador idiomático sobrecargado (una pequeña maravilla aquí, ya que Java no permite la sobrecarga del operador personalizado).

Por lo tanto, puede nacer de una necesidad didáctica (aunque yo diría que esto es solo una mala enseñanza) o puede usarse para ilustrar un principio que de otra manera es bastante difícil de demostrar en Java.

La expresion

"" + i

conduce a la conversión de cadenasi en tiempo de ejecución. El tipo general de la expresión es String. iprimero se convierte en un Integerobjeto ( new Integer(i)), luego String.valueOf(Object obj)se llama. Entonces es equivalente a

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

Obviamente, esto es un poco menos eficaz que simplemente llamar, String.valueOf(new Integer(i))lo que producirá el mismo resultado.

La ventaja de esto ""+ies que escribir es más fácil / más rápido y algunas personas podrían pensar que es más fácil de leer. No es un olor a código, ya que no indica ningún problema más profundo.

(Referencia: JLS 15.8.1 )

Personalmente, no veo nada malo en este código.

Es bastante útil cuando desea registrar un valor int, y el registrador solo acepta una cadena. Diría que tal conversión es conveniente cuando necesita llamar a un método que acepta una Cadena, pero tiene un valor int.

En cuanto a la elección entre Integer.toStringo String.valueOf, todo es cuestión de gustos.
... E internamente, por cierto , String.valueOfllama al Integer.toStringmétodo. :)

La otra forma que conozco es de la Integerclase:

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

Un ejemplo concreto (aunque no creo que necesite ninguno):

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

También funciona para otros tipos primitivos, por ejemplo Double.toString .

Ver aquí para más detalles.

Esta técnica se enseñó en una clase de introducción a Java de nivel universitario que tomé hace más de una década. Sin embargo, debo señalar que, IIRC, todavía no habíamos llegado a los métodos de clase String e Integer.

La técnica es simple y rápida de escribir. Si todo lo que estoy haciendo es imprimir algo, lo usaré (por ejemplo,System.out.println("" + i); ,. Sin embargo, creo que no es la mejor manera de hacer una conversión, ya que me toma un segundo pensar en lo que sucede cuando se está usando de esta manera, además, si el rendimiento es una preocupación, parece más lento (más abajo, así como en otras respuestas).

Personalmente, prefiero Integer.toString (), ya que es obvio lo que está sucediendo. String.valueOf () sería mi segunda opción, ya que parece ser confuso (sea testigo de los comentarios después de la respuesta de darioo).

Solo por sonrisas :) Escribí clases para probar las tres técnicas: "" + i, Integer.toString y String.ValueOf. Cada prueba acaba de convertir las entradas de 1 a 10000 en cadenas. Luego ejecuté cada uno a través del comando de tiempo de Linux cinco veces. Integer.toString () fue ligeramente más rápido que String.valueOf () una vez, empataron tres veces, y String.valueOf () fue más rápido una vez; sin embargo, la diferencia nunca fue más que un par de milisegundos.

La técnica "" + i fue más lenta que ambas en cada prueba, excepto en una, cuando fue 1 milisegundo más rápido que Integer.toString () y 1 milisegundo más lento que String.valueOf () (obviamente en la misma prueba donde String.valueOf () fue más rápido que Integer.toString ()). Si bien generalmente solo era un par de milisegundos más lento, hubo una prueba en la que fue aproximadamente 50 milisegundos más lento. YMMV .

Hay varias formas de convertir a cadenas:

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

Depende de cómo quieras usar tu String. Esto puede ayudar:

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

Principalmente lo mismo en SimonJ. Realmente no me gusta el idioma "" + i. Si dice String.valueOf (i), Java convierte el entero en una cadena y devuelve el resultado. Si dice "" + i, Java crea un objeto StringBuilder, le agrega una cadena vacía, convierte el entero en una cadena, lo agrega al StringBuilder, luego convierte el StringBuilder en una cadena. Eso son muchos pasos adicionales. Supongo que si lo haces una vez en un gran programa, no es gran cosa. Pero si está haciendo esto todo el tiempo, está haciendo que la computadora haga un montón de trabajo extra y creando todos estos objetos adicionales que luego deben limpiarse. No quiero volverme fanático de la microoptimización, pero tampoco quiero ser un derroche inútil.

String strI = String.valueOf(i);

String string = Integer.toString(i);

Ambas formas son correctas.

Hay muchas formas de convertir un entero en una cadena:

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)

Hay tres formas de convertir a cadenas

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

Usar "" + i es la forma más corta y sencilla de convertir un número en una cadena. No es el más eficiente, pero es el más claro en mi humilde opinión y eso suele ser más importante. Cuanto más simple sea el código, es menos probable que cometa un error.

Personalmente, creo que "" + i parece que el cartel original de la pregunta dice "maloliente". He usado muchos lenguajes OO además de Java. Si se pretendía que esa sintaxis fuera apropiada, entonces Java interpretaría solo el i sin necesidad de que "" se desea convertir a una cadena y lo haría ya que el tipo de destino no es ambiguo y solo se proporcionaría un único valor a la derecha . El otro parece un "truco" para engañar al compilador, un mal humor cuando se consideran diferentes versiones de Javac hechas por otros fabricantes o desde otras plataformas si el código alguna vez necesita ser portado. Diablos por mi dinero, debería gustarle a muchos otros OOL tomar un Typecast: (String) i. guiños

Dada mi forma de aprender y para facilitar la comprensión de tal construcción al leer el código de otros rápidamente, voto por el método Integer.toString (i). Olvidando una o dos cosas sobre cómo Java implementa las cosas en segundo plano frente a String.valueOf (i) este método me parece correcto y dice exactamente lo que está sucediendo: tengo e Integer y deseo que se convierta en String.

Un buen punto de vista un par de veces es que quizás solo usar StringBuilder por adelantado es una buena respuesta para construir cadenas mixtas de texto e ints u otros objetos, ya que eso es lo que se usará en el fondo de todos modos, ¿verdad?

Solo mis dos centavos arrojados al gatito ya bien pagado de las respuestas a la pregunta de Mans ... sonrisas

EDITAR A MI PROPIA RESPUESTA DESPUÉS DE ALGUNA REFLEXIÓN:

Ok, Ok, estaba pensando en esto un poco más y String.valueOf (i) también es perfectamente bueno y dice: Quiero una cadena que represente el valor de un número entero. jajaja, el inglés es mucho más difícil de analizar que Java! Pero, dejo el resto de mi respuesta / comentario ... Siempre me enseñaron a usar el nivel más bajo de una cadena de método / función si es posible y todavía mantiene la legibilidad, de modo que si String.valueOf llama a Integer.toString, entonces ¿Por qué usar una naranja entera? si de todos modos lo pelarás, ¿mmm?

Para aclarar mi comentario sobre StringBuilder, construyo muchas cadenas con combos de texto en su mayoría literales e int y terminan siendo largos y feos con llamadas a las rutinas mencionadas anteriormente incrustadas entre los + 's, así que me parece si esos se vuelven De todos modos, SB se opone y el método append tiene sobrecargas, podría ser más limpio seguir adelante y usarlo ... Entonces, supongo que ahora tengo hasta 5 centavos en este, ¿eh? jajaja ...

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

Prueba la conversión simple

char c = (char) i;