Différence entre parseInt et valueOf en java?

Bien, l'API pour Integer.valueOf(String) ne disent en effet que la String est interprété exactement comme s'il était donné à Integer.parseInt(String). Cependant, valueOf(String) renvoie une new Integer() objet alors que parseInt(String) renvoie une primitive int.

Si vous voulez profiter du potentiel de la mise en cache des prestations de Integer.valueOf(int), vous pouvez également utiliser cette horreur:

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

Maintenant, si ce que vous voulez est l'objet et non pas le primitif, puis à l'aide valueOf(String) peut être plus intéressant que de faire un nouvel objet de parseInt(String) parce que l'ancien est toujours présent à travers Integer, Long, Double, etc.

Integer.valueOf(s)

est similaire à

new Integer(Integer.parseInt(s))

La différence est valueOf() retourne un Integer, et parseInt() retourne un int (un type primitif). Notez également que valueOf() pouvez revenir à une mise en cache Integer exemple, qui peut causer de la confusion où le résultat de == tests semblent par intermittence correcte. Avant l'autoboxing il pourrait y avoir une différence dans le confort, après java 1.5, il n'a pas vraiment d'importance.

En outre, Integer.parseInt(s) peut prendre des primitives de type de données ainsi.

Entier.parseInt pouvez simplement retourner int comme type natif.

Entier.valueOf peuvent avoir besoin d'allouer un objet Integer, à moins que entier se trouve être l'un des préaffectés ceux. Cela coûte de plus en plus.

Si vous avez besoin de tout type natif, utiliser parseInt. Si vous avez besoin d'un objet, utilisez valueOf.

Aussi, à cause de cette allocation, l'autoboxing n'est pas réellement une bonne chose dans tous les sens. Il peut ralentir les choses.

L'analyse* les variations de retour de types primitifs et les valueOf versions de retour des Objets. Je crois que le valueOf versions également utiliser une référence interne de la piscine pour retourner le MÊME objet pour une valeur donnée, pas juste un autre exemple avec la même valeur.

Si vous cochez la classe Integer, vous trouverez que valueof appel parseInt méthode. La grande différence, c'est la mise en cache lorsque vous appelez valueof API . Il cache si la valeur est comprise entre -128 à 127 Veuillez trouver ci-dessous le lien pour plus d'informations

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

Entier.parseInt accepter uniquement les Cordes et revenir primitive de type entier (int).

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

Iteger.valueOf accepter int et String.
Si la valeur est une Chaîne, valueOf convertir le simple int utiliser parseInt et de retour de new Integer si l'entrée est inférieure à -128 ou supérieure à 127.
Si l'entrée est dans la plage (-128 à 127) il renvoie toujours l'Entier des objets à partir d'un interne IntegerCache. Classe Integer maintient un intérieur statique IntegerCache classe qui sert de cache et détient entier des objets de -128 à 127, et c'est pourquoi, lorsque nous essayons d'obtenir des objet integer pour 127 (par exemple), nous obtenons toujours le même objet.

Iteger.valueOf(200) donnera un nouvel Entier à partir de 200. C'est comme new Integer(200)
Iteger.valueOf(127) est le même que Integer = 127;

Si vous avez l'habitude de le convertir en Chaîne de caractères à l'Entier usage Iteger.valueOf.

Si vous avez l'habitude de le convertir en Chaîne de caractères pour la simple int utilisation Integer.parseInt. Il travaille plus vite.

  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() {}
}

Et en comparant Entier.valueOf(127) == Integer.valueOf(127) return true

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 

Parce qu'il prend l'Entier des objets avec les mêmes références, à partir du cache.

Mais Entier.valueOf(128) == Integer.valueOf(128) est faux, parce que 128 est de IntegerCache gamme et qu'elle renvoie de nouveau Entier, de sorte que les objets ont des références différentes.