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

Me pregunto por qué String.valueOf(int i)existe el método . Estoy utilizando este método para convertir inten Stringy acabo de descubrir el Integer.toString(int i)método.

Después de mirar la implementación de estos métodos, vi que el primero llama al segundo. Como consecuencia, todas mis llamadas String.valueOf(int i)implican una llamada más que llamar directamenteInteger.toString(int i)

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

En el tipo de cadena 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 has presentado: Entonces, para enteros

Integer.toString(int i)

para doble

Double.toString(double d)

y así

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

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 la muestra 2, tenemos que hacer dos cambios, a diferencia de la muestra uno.

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

Una gran diferencia es que si invoca toString()en un objeto nulo obtendrá un NullPointerExceptionmientras que, al usarlo, String.valueOf()es posible que no compruebe si es nulo.

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

NB Resultados de perfiles

Promedio intToString = 5368 ms, Promedio stringValueOf = 5689 ms (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 observa el código fuente de la Stringclase, en realidad llama Integer.toString()cuando llama valueOf().

Dicho esto, Integer.toString()podría ser un poco más rápido si las llamadas al método no están optimizadas en el momento de la compilación (que probablemente sí lo estén).

La implementación de lo String.valueOf()que ve es la forma más sencilla de cumplir con el contrato especificado en la API: "La representación es exactamente la que devuelve el Integer.toString()método de un argumento".

Para responder a la pregunta de los OP, es simplemente un contenedor auxiliar para tener la otra llamada, y se reduce a la elección de estilo y eso es todo. Creo que hay mucha información errónea aquí y lo mejor que puede hacer un desarrollador de Java es mirar la implementación de cada método, está a uno o dos clics de distancia en cualquier IDE. Verá claramente que String.valueOf(int)simplemente está llamandoInteger.toString(int) te .

Por lo tanto, no hay absolutamente ninguna diferencia, ya que ambos crean un búfer de caracteres, recorren los dígitos del número, luego lo copian en una nueva Cadena y lo devuelven (por lo tanto, cada uno está creando un objeto Cadena). La única diferencia es una llamada adicional, que el compilador elimina a una sola llamada de todos modos.

Por lo tanto, no importa a qué llame, aparte de la coherencia del código. En cuanto a los comentarios sobre nulos, se necesita una primitiva, por lo tanto, no puede ser nulo. Obtendrá un error en tiempo de compilación si no inicializa el int que se pasa. Por lo tanto, no hay diferencia en cómo maneja los nulos, ya que son inexistentes en este caso.

No debe preocuparse por esta llamada adicional que le costará problemas de eficiencia. Si hay algún costo, será mínimo y debería ser insignificante en el panorama general de las cosas.

Quizás la razón por la cual ambos existen es para ofrecer legibilidad. En el contexto de muchos tipos que se convierten String, entonces varias llamadas a String.valueOf(SomeType)pueden ser más legibles que varias SomeType.toStringllamadas.

mi apertura es valueof () siempre llamada tostring () para la representación y, por lo tanto, para la representación del tipo primitivo valueof se generaliza. y Java por defecto no admite el tipo de datos, pero define su trabajo con objaect y la clase se hizo todo en cllas y se hizo object .here Integer.toString (int i) crea un límite de conversión para solo enteros.

No hay diferencias entre Integer.toString (5) y String.valueOf (5);

porque String.valueOf devuelve:

public static String valueOf(int i) {
    return Integer.toString(i);
}
public static String valueOf(float f) {
    return Float.toString(f);
}

etc.

Usando el método String.valueOf () no tiene que preocuparse por los datos (ya sea int, long, char, char [], boolean, Object), simplemente puede llamar:

• valor de cadena estática Of ()

utilizando la única sintaxis String.valueOf () puede convertir lo que pase como parámetro en String y devolverlo.

De lo contrario, si usa Integer.toString (), Float.toString () etc. (es decir, SomeType.toString ()), deberá verificar el tipo de datos del parámetro que desea convertir en cadena. Por lo tanto, es mejor usar String.valueOf () para tales conversiones.

Si tiene una matriz de clase de objeto que contiene diferentes valores como Integer, Char, Float, etc., utilizando el método String.valueOf () puede convertir fácilmente los elementos de dicha matriz en forma de cadena. Por el contrario, si desea utilizar SomeType.toString (), al principio deberá conocer sus clases de tipo de datos (tal vez mediante el uso del operador "instanceOf") y luego solo podrá proceder a una conversión tipográfica.

El método String.valueOf () cuando se llama coincide con el parámetro que se pasa (ya sea Integer, Char, Float, etc.) y al usar la sobrecarga de métodos llama a ese método "valueOf ()" cuyo parámetro coincide, y luego dentro de ese método es una llamada directa al método "toString ()" correspondiente.

Por lo tanto, podemos ver cómo se elimina la sobrecarga de verificar el tipo de datos y luego llamar al método "toString ()" correspondiente. Solo necesitamos llamar al método String.valueOf (), sin preocuparnos por lo que queremos convertir a String.

Conclusión: el método String.valueOf () tiene su importancia al costo de una llamada más.

Encadenar()

1. está presente en la clase Object, generalmente anulada en la clase derivada
2. La conversión de texto a la clase apropiada es necesaria para llamar al método toString ().

valor de()

1. Método estático sobrecargado presente en la clase String.

2. maneja tipos primitivos así como tipos de objetos.

   Integer a = null;
   System.out.println(Integer.toString()) ; NUll pointer exception
   System.out.println(String.valueOf() ; give NULL as value

mira este enlace es muy bueno http://code4reference.com/2013/06/which-one-is-better-valueof-or-tostring/