Integer.toString(int i) vs String.valueOf(int i) en Java

Me pregunto por qué el método String.valueOf(int i) existe? Estoy usando este método para convertir int en String y acabo de descubrir el Integer.toString(int i) método.

Después de ver la implementación de estos métodos, vi que el primero está llamando al segundo. Como consecuencia, todas mis llamadas a String.valueOf(int i) supone una llamada más que llamar directamente Integer.toString(int i)

En tipo String tenemos varios métodos valueOf

static String   valueOf(boolean b) 
static String   valueOf(char c) 
static String   valueOf(char[] data) 
static String   valueOf(char[] data, int offset, int count) 
static String   valueOf(double d) 
static String   valueOf(float f) 
static String   valueOf(int i) 
static String   valueOf(long l) 
static String   valueOf(Object obj) 

Como podemos ver, esos métodos son capaces de resolver todo tipo de números.

cada implementación de un método específico como el que ha presentado: Entonces, para los números enteros, tenemos

Integer.toString(int i)

para doble

Double.toString(double d)

etcétera

En mi opinión, esto no es algo histórico, pero es más útil para un desarrollador usar el método valueOf de la clase String que del tipo adecuado, ya que nos lleva a realizar menos cambios cuando queremos cambiar el tipo en el que estamos operando.

Muestra 1:

public String doStuff(int num) {

  // Do something with num...

  return String.valueOf(num);

 }

Muestra2:

public String doStuff(int num) {
  
 // Do something with num...
 
 return Integer.toString(num);

 }

Como vemos en el ejemplo 2, tenemos que hacer dos cambios, al contrario del ejemplo uno.

En mi conclusión, usando el valueOf El método de la clase String es más flexible y por eso está disponible allí.

Una gran diferencia es que si invocas toString() en un objeto nulo obtendrás un NullPointerException mientras que, utilizando String.valueOf() usted no puede verificar nulo.

Sólo dos formas diferentes de hacer lo mismo. Puede ser una razón histórica (no recuerdo si uno vino antes que el otro).

La clase String proporciona métodos valueOf para todos los tipos primitivos y el tipo de objeto, por lo que asumo que son métodos convenientes a los que se puede acceder a través de una clase.

NB Perfilado de resultados

Promedio intToString = 5368ms, promedio stringValueOf = 5689ms (para 100,000,000 operaciones)

public class StringIntTest {


    public static long intToString () {
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            String j = Integer.toString(i);
        }
        long finishTime = System.currentTimeMillis();

        return finishTime - startTime;
    }

    public static long stringValueOf () {

        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            String j = String.valueOf(i);
        }
        long finishTime = System.currentTimeMillis();

        return finishTime - startTime;
    }

    public static void main(String[] args) {
        long intToStringElapsed = 0;
        long stringValueOfElapsed = 0;
        for (int i = 0; i < 10; i++) {
            intToStringElapsed += intToString();
            stringValueOfElapsed+= stringValueOf();
        }
        System.out.println("Average intToString = "+ (intToStringElapsed /10));
        System.out.println("Average stringValueOf = " +(stringValueOfElapsed / 10));
    }
}

De las fuentes de Java:

/**
 * Returns the string representation of the {@code int} argument.
 * <p>
 * The representation is exactly the one returned by the
 * {@code Integer.toString} method of one argument.
 *
 * @param   i   an {@code int}.
 * @return  a string representation of the {@code int} argument.
 * @see     java.lang.Integer#toString(int, int)
 */
public static String valueOf(int i) {
    return Integer.toString(i);
}

Entonces dan exactamente el mismo resultado y uno de hecho llama al otro. String.valueOf es más flexible si puede cambiar el tipo más adelante.

Si nos fijamos en el código fuente de la String clase, en realidad llama Integer.toString() cuando usted llama valueOf().

Habiendo dicho eso, Integer.toString() podría ser un poco más rápido si las llamadas al método no están optimizadas en tiempo de compilación (que probablemente lo estén).

La implementación de String.valueOf() que ves es la forma más sencilla de cumplir con el contrato especificado en la API: “La representación es exactamente la devuelta por el Integer.toString() método de un argumento”.