java - num - Integer.toString(int i) frente a String.valueOf(int i)

string valueof num);

Question

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

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

Answer 1

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 tarde.

Answer 2

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 método específico como usted ha presentado: Entonces, para enteros tenemos

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 valueOf de la clase String que del tipo apropiado, ya que nos lleva a hacer menos cambios.

Muestra 1:

public String doStuff(int num) {

  // Do something with num...

  return String.valueOf(num);

 }

Sample2:

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 método valueOf de la clase String es más flexible y es por eso que está disponible allí.

Answer 3

Encadenar()

1. está presente en la clase Object, generalmente anulado en clase derivada
2. Encasillar a la clase apropiada es necesario para llamar al método String ().

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/

Answer 4

La clase String proporciona métodos valueOf para todos los tipos primitivos y tipo de objeto, así que supongo que son métodos de conveniencia a los que se puede acceder a través de una clase.

NB Perfiles 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));
    }
}

Answer 5

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

Answer 6

No debe preocuparse por esta llamada extra que le cuesta 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 ambas existen es para ofrecer legibilidad. En el contexto de muchos tipos que se convierten a String , varias llamadas a String.valueOf(SomeType) pueden ser más legibles que varias llamadas SomeType.toString .

Answer 7

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.

Answer 8

Para responder a la pregunta de OPs, es simplemente un contenedor de ayuda para tener la otra llamada, y se reduce a la elección de estilo y eso es todo. Creo que hay mucha desinformación aquí y lo mejor que un desarrollador de Java puede hacer 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á llamando Integer.toString(int) por usted.

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

Por lo tanto, no importa a quién llame, aparte de la consistencia del código. En cuanto a los comentarios sobre nulls, se necesita un primitivo, ¡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 valores nulos ya que no existen en este caso.

Answer 9

Si observa el código fuente de la clase String , en realidad llama a Integer.toString() cuando llama a 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 tiempo de compilación (que probablemente sean).

Answer 10

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

Answer 11

Una gran diferencia es que si invocas toString() en un objeto nulo obtendrás una NullPointerException mientras que, usando String.valueOf() es posible que no puedas verificar null.

Answer 12

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

• valor de cadena estáticoOf ()

usando la única sintaxis String.valueOf () puede pasar lo que pase cuando un parámetro se convierte a String y se devuelve ..

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. Entonces, es mejor usar String.valueOf () para tales conversiones.

Si tiene una matriz de clase de objeto que contiene valores diferentes como Integer, Char, Float, etc., con el método String.valueOf () puede convertir fácilmente los elementos de dicha matriz en Cadena. Por el contrario, si quiere utilizar SomeType.toString (), primero deberá conocer sus clases de tipos de datos (tal vez utilizando el operador "instanceOf") y solo podrá proceder a un encasillado.

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

Entonces, podemos ver cómo se elimina la sobrecarga de verificar el tipo de datos y luego llamar al método correspondiente "toString ()". 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 solo al costo de una llamada más.

Answer 13

mi apertura es valueof () siempre llamada tostring () para representación y así para la representación de tipo primitivo valueof es generalizada. Java por defecto no admite Data type pero define su trabajo con objaect y class hace todo en cllas y made objeto .here Integer.toString (int i) crea un límite que la conversión para solo entero.