Différence entre parseInt et value of en java?
Quelle est la différence entre ces deux méthodes? Ils semblent faire exactement la même chose à moi (va aussi pour parseFloat() , parseDouble() , parseLong() etc, En quoi sont-ils différents de Long.valueOf(string) ?
éditer: aussi, lequel de ceux-ci est préférable et utilisé le plus souvent par convention?
11 réponses
Eh bien, L'API pour Integer.valueOf(String) ne dit en effet que le String est interprété exactement comme si elle a été donnée à Integer.parseInt(String) . Toutefois, valueOf(String) renvoie une new Integer() objet alors que parseInt(String) renvoie une primitive int .
si vous voulez profiter des avantages potentiels de la mise en cache Integer.valueOf(int) , vous pourriez aussi utilisez cette horreur:
Integer k = Integer.valueOf(Integer.parseInt("123"))
maintenant, si ce que vous voulez est l'objet et non le primitif, alors utiliser valueOf(String) peut être plus attrayant que de faire un nouvel objet à partir de parseInt(String) parce que le premier est constamment présent à travers Integer , Long , Double , etc.
de ce forum :
parseInt()renvoie l'entier primitif type ( int ), par lequelvalueOfretourne de java.lang.Entier , qui est l'objet représentant de l'entier. Y sont circonstances où vous pourriez un objet Integer, au lieu de type de primitive.de 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 un Integer , et parseInt() renvoie un int (un type primitif). Notez également que valueOf() peut renvoyer une instance Integer en cache, ce qui peut causer des résultats confus lorsque le résultat des tests == semble par intermittence correct. Avant autoboxing il pourrait y avoir une différence de commodité, après java 1.5 it n'a pas vraiment d'importance.
de plus, Integer.parseInt(s) peut aussi 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);
}
entier.parseInt peut 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. Cela coûte de plus en plus.
si vous avez besoin de type natif, utilisez parseInt. Si vous avez besoin d'un objet, utilisez value of.
aussi, à cause de cette allocation potentielle, l'autoboxing n'est pas vraiment une bonne chose dans tous les sens. Il peut ralentir les choses.
parce que vous utilisez peut-être jdk1.5 + et là il est auto conversion en int. Donc dans votre code son premier retour entier puis auto converti en int.
votre code est le même que
int abc = new Integer(123);
L'analyse* les variations de retour de types primitifs et les valueOf versions de retour des Objets. Je crois que la valeur des versions utilisera également un pool de référence interne pour retourner le même objet pour une valeur donnée, et pas seulement une autre instance avec la même valeur interne.
Depuis valueOf renvoyer un nouvel objet Integer pourquoi le code ci-dessous est correct?
String base5String = "230";
int result = Integer.valueOf(base5String);
si vous vérifiez la classe entière, vous trouverez la méthode valueof call parseInt. La grande différence est la mise en cache lorsque vous appelez valueof API . Il cache si la valeur est entre -128 à 127 S'il vous plaît trouver ci-dessous le lien pour plus d'information
http://docs.oracle.com/javase/7/docs/api/java/lang/Integer.html
public static Integer valueOf (String s)
- l'argument est interprété comme représentant un entier décimal signé, exactement comme si l'argument était donné au parseInt(java.lang.Chaîne de caractères) de la méthode.
-
le résultat est un objet entier qui représente la valeur entière spécifiée par la chaîne.
-
en d'autres termes, cette méthode renvoie un objet entier égal à la valeur de: Nouveau entier (entier.parseInt (s))
- en cas de ValueOf -> il crée un objet entier. pas un type primitif et non pas une méthode statique.
- dans le cas de ParseInt.ParseFloat - > il renvoie le type primitif respectif. et est une méthode statique.
nous devrions utiliser n'importe lequel en fonction de nos besoins. En cas de valeur de comme il instancie un objet. il consommera plus de ressources si nous n'avons besoin que de la valeur d'un texte, alors nous devrions utiliser parseInt, parseFloat etc.