java - integer.tostring para que sirve

Java int a String-Integer.toString(i) vs nuevo Integer(i).toString()

Question

A veces java me desconcierta.
Tengo una gran cantidad de inicializaciones int para hacer.

¿Cuál es la diferencia real ?

1. Integer.toString(i)
2. new Integer(i).toString()

Answer 1

1. new Integer(i).toString();

   Esta declaración crea el objeto del Integer y luego llama a sus métodos toString(i) para devolver la representación de String del valor del Integer .

2. Integer.toString(i);

   Devuelve el objeto String que representa el int específico (entero) , pero aquí toString(int) es un método static .

El resumen es, en primer caso, que devuelve la representación de cadena de objetos, mientras que en el segundo caso devuelve la representación de cadena de entero.

Answer 2

1. Integer.toString(i)

Integer i = new Integer(8);
// returns a string representation of the specified integer with radix 8
String retval = i.toString(516, 8);
System.out.println("Value = " + retval);

2. new Integer(i).toString()

 int i = 506;
String str = new Integer(i).toString();
System.out.println(str + " : " + new Integer(i).toString().getClass());////506 : class java.lang.String

Answer 3

Aquí Integer.toString llama al método estático en la clase Integer. No requiere que el objeto llame.

Si llama al new Integer(i) , primero crea una instancia de tipo Integer, que es un objeto Java completo que encapsula el valor de su int i. Luego llama al método toString para pedirle que devuelva una representación de cadena de sí mismo.

Answer 4

Aunque me gusta la recomendación de fhucho.

String.valueOf(i)

La ironía es que este método realmente llama

Integer.toString(i)

Por lo tanto, use String.valueOf(i) si le gusta cómo se lee y no necesita radix, pero también sabe que es menos eficiente que Integer.toString(i) .

Answer 5

En términos de medición de rendimiento, si está considerando el rendimiento de tiempo, entonces Integer.toString (i); es caro si llama menos de 100 millones de veces. De lo contrario, si son más de 100 millones de llamadas, el nuevo Integer (10) .toString () tendrá un mejor desempeño.

A continuación se muestra el código a través del cual puede intentar medir el rendimiento,

public static void main(String args[]) {
int MAX_ITERATION = 10000000;
long starttime = System.currentTimeMillis();
for (int i = 0; i < MAX_ITERATION; ++i) {
String s = Integer.toString(10);
}
long endtime = System.currentTimeMillis();
System.out.println("diff1: " + (endtime-starttime));
starttime = System.currentTimeMillis();
for (int i = 0; i < MAX_ITERATION; ++i) {
String s1 = new Integer(10).toString();
}
endtime = System.currentTimeMillis();
System.out.println("diff2: " + (endtime-starttime));
}

En términos de memoria, la

nuevo Integer (i) .toString ();

tomará más memoria ya que creará el objeto cada vez, por lo que se producirá la fragmentación de la memoria.

Answer 6

La forma simple es simplemente concatenar "" con un entero:

int i = 100;
String s = "" + i;

ahora s tendrá 100 como valor de cadena.

Answer 7

Mejor:

Integer.valueOf(i).toString()

Answer 8

Otra opción es el método String.valueOf estático.

String.valueOf(i)

Se siente un poco más correcto que Integer.toString(i) para mí. Cuando el tipo de i cambia, por ejemplo, de int a double , el código se mantendrá correcto.

Answer 9

También recomiendo altamente usar

int integer = 42;
String string = integer + "";

Simple y eficaz.

Answer 10

Integer.toString llama al método estático en la clase Integer . No necesita una instancia de Integer .

Si llama al new Integer(i) , creará una instancia de tipo Integer , que es un objeto Java completo que encapsula el valor de su int. Luego llama al método toString para pedirle que devuelva una representación de cadena de sí mismo .

Si todo lo que desea es imprimir un int , usaría el primero porque es más ligero, más rápido y no usa memoria adicional (aparte de la cadena devuelta).

Si desea un objeto que representa un valor entero, por ejemplo, para ponerlo dentro de una colección, usaría el segundo, ya que le da un objeto de pleno derecho para hacer todo tipo de cosas que no puede hacer con un int .

Answer 11

new Integer(i).toString() crea primero un objeto de envoltura (redundante) alrededor de i (que a su vez puede ser un objeto de envoltura Integer ).

Se prefiere Integer.toString(i) porque no crea ningún objeto innecesario.