java - convertir - ¿Cómo convierto de int a String?

convertir int a string java

Question

Estoy trabajando en un proyecto donde todas las conversiones de int a String se realizan así:

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

No estoy familiarizado con Java. ¿Es esta práctica habitual o algo está mal, como supongo?

Answer 1

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

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

Answer 2

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

String strI = Integer.toString(i);

Answer 3

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, aún no habíamos llegado a los métodos de clase String y Integer.

La técnica es simple y rápida de escribir. Si todo lo que hago 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 se necesita una Pensemos en qué es lo que sucede cuando se usa 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 (atestigua los comentarios después de la respuesta de Darioo).

Solo para sonreír :) 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 de los comandos de time Linux cinco veces. Integer.toString () fue un poco más rápido que String.valueOf () una vez, se empataron tres veces y String.valueOf () fue más rápido una vez; Sin embargo, la diferencia nunca fue más de un par de milisegundos.

La técnica "" + i fue más lenta que las dos en todas las pruebas excepto en una, cuando fue 1 milisegundo más rápido que Integer.toString () y 1 milisegundo más lenta que String.valueOf () (obviamente en la misma prueba donde String.valueOf () fue más rápido que Integer.toString ()). Si bien por lo general solo fue un par de milisegundos más lento, hubo una prueba en la que fue unos 50 milisegundos más lento. YMMV .

Answer 4

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)

Answer 5

Hay tres formas de convertir a cuerdas

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

Answer 6

Hay varias formas de convertir a cadenas:

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

Answer 7

La expresion

"" + i

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

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

Obviamente, esto tiene un poco menos de rendimiento que solo llamar a String.valueOf(new Integer(i)) que producirá el mismo resultado.

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

(Referencia: JLS 15.8.1 )

Answer 8

La otra forma que conozco es de la clase Integer :

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

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

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

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

Vea aquí para más detalles.

Answer 9

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

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

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

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 a Integer.getChars() , que es lo que Integer.toString() hubiera hecho de todos modos), pero funciona.

Para responder al 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

Inicializa 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;

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

Answer 10

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. Entonces, usar algo como String.valueOf(…) confundiría a los estudiantes.

• Es una ilustración de la "sobrecarga del operador"; de hecho, esto se nos vendió como el operador sobrecargado idiomático (no es de extrañar, 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 usarse para ilustrar un principio que, por lo demás, es bastante difícil de demostrar en Java.

Answer 11

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

"" + i

porque no expresa lo que realmente quiero hacer ² .

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

Integer.toString(i)

O, no mi preferido, pero aún mejor que la concatenación, obtener una representación de cadena de un objeto (entero):

String.valueOf(i)

^{1. Para el código que se llama muy a menudo, como en los bucles, la optimización también es un punto para no usar 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;}

Answer 12

No es una buena manera.

Al hacer la conversión de int a string, esto debería ser usado:

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

Answer 13

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

Dada mi forma de aprender y para facilitar la comprensión de este tipo de construcción cuando leo el código de otros rápidamente, voto por el método Integer.toString (i). Olvidando un ns o dos en 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, Integer y deseo que se convierta en String.

Un buen punto hecho un par de veces es, tal vez, usar StringBuilder por adelantado, es una buena respuesta para crear cadenas de texto mezcla de texto e ints u otros objetos, ya que eso es lo que se usará en el fondo, ¿no?

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

EDITA 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 entero. lol, 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 aún así se mantiene legible, así que si String.valueOf llama a Integer.toString, entonces ¿Por qué usar una naranja entera? Si tu solo vas a pelarlo de todos modos, Hmmm?

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 las llamadas a las rutinas antes mencionadas incrustadas entre los + ''s, así que me parece que se conviertan en De todos modos, SB se opone y el método de adición tiene sobrecargas, podría ser más limpio seguir adelante y usarlo ... Así que supongo que ahora tengo hasta 5 centavos en este caso, ¿eh? jajaja

Answer 14

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. Yo diría que una conversión de este tipo 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.toString o String.valueOf , todo es cuestión de gustos.
... Y internamente, el String.valueOf llama al método Integer.toString por cierto. :)

Answer 15

Prueba el encasillado simple

char c = (char) i;

Answer 16

Sobre todo lo mismo en SimonJ. Realmente no me gusta el "" + i idioma. 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 número entero en una cadena, agrega esto a StringBuilder y luego convierte StringBuilder en una cadena. Eso es un montón de pasos adicionales. Supongo que si lo haces una vez en un gran programa, no es gran cosa. Pero si haces esto todo el tiempo, haces que la computadora haga un montón de trabajo adicional y cree todos estos objetos adicionales que luego hay que limpiar. No quiero ser fanático de la microoptimización, pero tampoco quiero ser inútilmente inútil.

Answer 17

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 IMHO más claro y eso suele ser más importante. Cuanto más simple sea el código, menor será la probabilidad de cometer un error.

Answer 18

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

Answer 19

String strI = String.valueOf(i);
String string = Integer.toString(i);

Ambas formas son correctas.