¿Diferente entre parseInt () y valueOf () en java?

¿Cómo es parseInt()diferente de valueOf()?

Aparecen a hacer exactamente lo mismo que a mí (también se aplica parseFloat(), parseDouble(), parseLong()etc, en qué se diferencian de Long.valueOf(string)?

Además, ¿cuál de estos es preferible y se usa con más frecuencia por convención?

Bueno, la API para Integer.valueOf(String)sí dice que Stringse interpreta exactamente como si se le hubiera dado Integer.parseInt(String). Sin embargo, valueOf(String)devuelve un objeto mientras que devuelve un primitivo .new Integer()parseInt(String)int

Si desea disfrutar de los beneficios potenciales del almacenamiento en caché Integer.valueOf(int), también puede usar esta monstruosidad:

Integer k = Integer.valueOf(Integer.parseInt("123"))

Ahora bien, si lo que quiere es el objeto y no lo primitivo, a continuación, utilizando valueOf(String)puede ser más atractiva que hacer un nuevo objeto de parseInt(String)porque el primero es constantemente presente en todo Integer, Long, Double, etc.

De este foro :

parseInt()devuelve el tipo entero primitivo ( int ), por el cual valueOfdevuelve java.lang.Integer , que es el objeto representativo del entero. Hay circunstancias en las que puede desear un objeto Integer, en lugar de un tipo primitivo.

Por supuesto, otra diferencia obvia es que intValue es un método de instancia mediante el cual parseInt es un método estático.

Integer.valueOf(s)

es parecido a

new Integer(Integer.parseInt(s))

La diferencia es valueOf()devuelve un Integer, y parseInt()devuelve un int(un tipo primitivo). También tenga en cuenta que valueOf()puede devolver una Integerinstancia en caché , lo que puede causar resultados confusos donde el resultado de las ==pruebas parece intermitentemente correcto. Antes del autoboxing podría haber una diferencia en la conveniencia, después de Java 1.5 realmente no importa.

Además, también Integer.parseInt(s)puede tomar tipos de datos primitivos.

Mira las fuentes de Java: valueOfestá usando parseInt:

/**
 * Parses the specified string as a signed decimal integer value.
 *
 * @param string
 *            the string representation of an integer value.
 * @return an {@code Integer} instance containing the integer value
 *         represented by {@code string}.
 * @throws NumberFormatException
 *             if {@code string} cannot be parsed as an integer value.
 * @see #parseInt(String)
 */
public static Integer valueOf(String string) throws NumberFormatException {
    return valueOf(parseInt(string));
}

parseInt devoluciones int

/**
 * Parses the specified string as a signed decimal integer value. The ASCII
 * character \u002d ('-') is recognized as the minus sign.
 *
 * @param string
 *            the string representation of an integer value.
 * @return the primitive integer value represented by {@code string}.
 * @throws NumberFormatException
 *             if {@code string} cannot be parsed as an integer value.
 */
public static int parseInt(String string) throws NumberFormatException {
    return parseInt(string, 10);
}

Integer.parseInt solo puede devolver int como tipo nativo.

Integer.valueOf en realidad puede necesitar asignar un objeto Integer, a menos que ese entero sea uno de los preasignados. Esto cuesta más

Si solo necesita un tipo nativo, use parseInt. Si necesita un objeto, use valueOf.

Además, debido a esta asignación potencial, el autoboxing no es realmente bueno en todos los sentidos. Puede ralentizar las cosas.

Las variaciones parse * devuelven tipos primitivos y las versiones valueOf devuelven objetos. Creo que las versiones valueOf también usarán un grupo de referencia interno para devolver el MISMO objeto para un valor dado, no solo otra instancia con el mismo valor interno.

Debido a que puede estar usando jdk1.5 + y allí se convierte automáticamente a int. Entonces, en su código, primero regresa Integer y luego se convierte automáticamente a int.

tu código es el mismo que

int abc = new Integer(123);

Si marca la clase Integer, encontrará ese valor del método call parseInt. La gran diferencia es el almacenamiento en caché cuando se llama valueof API. Se almacena en caché si el valor está entre -128 y 127 A continuación, encontrará el enlace para obtener más información

http://docs.oracle.com/javase/7/docs/api/java/lang/Integer.html

public static Integer valueOf (String s)

1. El argumento se interpreta como la representación de un entero decimal con signo, exactamente como si el argumento se hubiera dado al método parseInt (java.lang.String).

2. El resultado es un objeto entero que representa el valor entero especificado por la cadena.

3. En otras palabras, este método devuelve un objeto Integer igual al valor de: new Integer (Integer.parseInt (s))

• valueOf - convierte a la clase Wrapper
• parseInt - convierte a tipo primitivo

Integer.parseInt acepta solo String y devuelve el tipo entero primitivo (int).

   public static int parseInt(String s) throws NumberFormatException {
        return parseInt(s,10);
    }

Iteger.valueOf accept int y String. Si el valor es String, valueOf lo convierte al int simple usando parseInt y devuelve un nuevo entero si la entrada es menor que -128 o mayor que 127. Si la entrada está en el rango (-128-127) siempre devuelve los objetos Integer de un IntegerCache interno. La clase entera mantiene una clase IntegerCache estática interna que actúa como caché y contiene objetos enteros de -128 a 127 y es por eso que cuando intentamos obtener un objeto entero para 127 (por ejemplo) siempre obtenemos el mismo objeto.

Iteger.valueOf(200)dará un nuevo número entero de 200. Es como new Integer(200) Iteger.valueOf(127)es lo mismo que Integer = 127;

Si no va a convertir String al uso Integer Iteger.valueOf.

Si no puede convertir String al simple int use Integer.parseInt. Funciona mas rapido.

  public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

  public static Integer valueOf(String s) throws NumberFormatException {
        return Integer.valueOf(parseInt(s, 10));
  }

  private static class IntegerCache {
      static final int low = -128;
      static final int high;
      static final Integer cache[];

    static {
        // high value may be configured by property
        int h = 127;
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // If the property cannot be parsed into an int, ignore it.
            }
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

        // range [-128, 127] must be interned (JLS7 5.1.7)
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
  }

Y comparando Integer.valueOf (127) == Integer.valueOf (127) devuelve verdadero

Integer a = 127; // Compiler converts this line to Integer a = Integer.valueOf(127);
Integer b = 127; // Compiler converts this line to Integer b = Integer.valueOf(127);
a == b; // return true 

Porque toma los objetos Integer con las mismas referencias del caché.

Pero Integer.valueOf (128) == Integer.valueOf (128) es falso, porque 128 está fuera del rango IntegerCache y devuelve un nuevo Integer, por lo que los objetos tendrán referencias diferentes.

1. En el caso de ValueOf -> está creando un objeto Integer. No es un tipo primitivo ni un método estático.
2. En el caso de ParseInt.ParseFloat -> devuelve el tipo primitivo respectivo. y es un método estático

Deberíamos usar cualquiera dependiendo de nuestra necesidad. En el caso de ValueOf ya que está instanciando un objeto. consumirá más recursos si solo necesitamos valor de algún texto, entonces deberíamos usar parseInt, parseFloat, etc.