Différence entre parseInt et valueOf en Java?
Quelle est la différence entre ces deux méthodes? Ils semblent faire exactement la même chose pour moi (va également pour parseFloat(), parseDouble(), parseLong() etc., en quoi sont-ils différents de Long.valueOf(string)?
Edit: De plus, lequel de ces choix est préférable et utilisé plus souvent par convention?
Eh bien, l’API pour Integer.valueOf(String) ne dit en effet que la String est interprétée exactement comme si elle avait été donnée à Integer.parseInt(String) . Cependant, valueOf(String) renvoie un objet newInteger() alors que parseInt(String) renvoie une primitive int.
Si vous souhaitez profiter des avantages potentiels de Integer.valueOf(int) en cache, vous pouvez également utiliser cette source de pollution visuelle:
Integer k = Integer.valueOf(Integer.parseInt("123"))
Maintenant, si ce que vous voulez est l’objet et non la primitive, utiliser valueOf(String) peut être plus intéressant que de créer un nouvel objet à partir de parseInt(String) car le premier est toujours présent dans Integer, Long, Double, etc.
De ce forum :
parseInt()renvoie un entier primitif type (int), oùvalueOfrenvoie Java.lang.Integer, qui est l'objet représentant de l'entier. Là sont des circonstances où vous voudrez peut-être un objet Integer, au lieu de type primitif.Bien sûr, une autre différence évidente est-ce que intValue est une méthode d'instance où parseInt est une méthode statique.
Integer.valueOf(s)
est similaire à
new Integer(Integer.parseInt(s))
La différence est valueOf() renvoie une Integer et parseInt() renvoie une int (type primitif). Notez également que valueOf() peut renvoyer une instance Integer en cache, ce qui peut entraîner des résultats confus lorsque le résultat des tests == semble être correct par intermittence. Avant autoboxing il pourrait y avoir une différence de confort, après Java 1.5, cela n’a plus vraiment d’importance.
De plus, Integer.parseInt(s) peut également prendre le type de données primitif.
Regardez les sources Java: valueOf utilise 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 renvoie 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 peut simplement renvoyer int en tant que type natif.
Integer.valueOf peut en fait avoir besoin d'allouer un objet Integer, à moins que cet entier ne soit l'un des objets préalloués. Cela coûte plus cher.
Si vous avez juste besoin d'un type natif, utilisez parseInt. Si vous avez besoin d'un objet, utilisez valueOf.
De plus, en raison de cette allocation potentielle, la substitution automatique n'est pas vraiment une bonne chose à tous les égards. Cela peut ralentir les choses.
Parce que vous utilisez peut-être jdk1.5 + et qu’il convertit automatiquement en int. Donc, dans votre code, il renvoie d'abord Integer, puis converti automatiquement en int.
votre code est le même que
int abc = new Integer(123);
Les variantes d'analyse * renvoient des types primitifs et les versions valueOf renvoient des objets. Je pense que les versions valueOf utiliseront également un pool de référence interne pour renvoyer l'objet SAME pour une valeur donnée, et pas simplement une autre instance avec la même valeur interne.
Integer.parseInt accepte uniquement String et renvoie le type entier primitif (int).
public static int parseInt(String s) throws NumberFormatException {
return parseInt(s,10);
}
Iteger.valueOf accepte int et String. Si value est String, valueOf le convertit en un simple int à l'aide de parseInt et renvoie un nouvel entier si l'entrée est inférieure à -128 ou supérieure à 127. Si l'entrée est dans la plage (-128 - 127), elle sera toujours renvoyer les objets Integer d'un IntegerCache interne. La classe Integer conserve une classe IntegerCache statique interne qui fait office de cache et contient des objets entiers de -128 à 127. C’est pourquoi, lorsque nous essayons d’obtenir un objet entier pour 127 (par exemple), nous obtenons toujours le même objet.
Utilisez Iteger.valueOf (200) si vous n'obtenez pas le nouvel entier Integer à partir de int 200. Iteger.valueOf (127) n'a aucun sens, car identique à Integer = 127;
Par exemple, si vous ne convertissez pas String en nouvel Integer ou Integer, utilisez Iteger.valueOf.
Si vous ne voulez pas convertir String en int simple, utilisez Integer.parseInt. Ça marche 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 Integer.valueOf (127) == Integer.valueOf (127) renvoie 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 les objets Integer avec les mêmes références du cache.
Mais Integer.valueOf (128) == Integer.valueOf (128) est false, car 128 est en dehors de la plage IntegerCache et renvoie un nouvel Integer, de sorte que les objets auront des références différentes.
Si vous cochez la classe Integer, vous trouverez la valeur de la méthode call parseInt call. La grande différence est la mise en cache lorsque vous appelez valueof API. Il cache si la valeur est comprise entre -128 et 127 Veuillez trouver ci-dessous le lien pour plus d'informations
http://docs.Oracle.com/javase/7/docs/api/Java/lang/Integer.html
public statique Integer valueOf (String s)
- L'argument est interprété comme représentant un entier décimal signé, exactement comme si l'argument était donné à la méthode parseInt (Java.lang.String).
Le résultat est un objet Integer qui représente la valeur entière spécifiée par la chaîne.
En d'autres termes, cette méthode retourne un objet Integer égal à la valeur de: New Integer (Integer.parseInt (s))
Puisque valueOf renvoie un nouvel objet Integer, pourquoi le code ci-dessous est-il correct?
String base5String = "230";
int result = Integer.valueOf(base5String);