La différence entre entier et int et l'explication détaillée de la méthode integer.values()

Déclaration : Cet article est un article réimprimé du blogueur. L'adresse originale se trouve à la fin de l'article.

Point de connaissance 1 : La différence entre entier et int

/*
* int sont les 8 types primitifs fournis par java Un des types de données. Java fournit des classes wrapper pour chaque type primitif. Integer est la classe wrapper fournie par Java pour int. La valeur par défaut de int est 0,
* et la valeur par défaut de Integer est null
* , c'est-à-dire que Integer peut distinguer la différence entre la valeur non attribuée et la valeur 0, int Il est impossible d'exprimer la situation non attribuée. Par exemple, si vous souhaitez exprimer la différence entre ne pas passer l'examen et la note de l'examen étant de 0
*, vous ne pouvez utiliser qu'Integer<.>
*. Dans le développement JSP, la valeur par défaut de Integer est null, donc lorsque l'expression el est utilisée pour l'afficher dans la zone de texte, la valeur est une chaîne vide et la valeur par défaut de int est 0, donc lorsque l'expression el est utilisée pour l'afficher dans la zone de texte
* , le résultat est 0, donc int ne convient pas comme type de données de formulaire de la couche Web.
* Dans Hibernate, si l'OID est défini comme type Integer, alors Hibernate peut déterminer si un objet est temporaire en fonction du fait que sa valeur est nulle
* , si le OID est défini comme type int, vous devez également définir son attribut de valeur non enregistrée sur 0 dans le fichier de mappage hbm.
* De plus, Integer fournit plusieurs méthodes de fonctionnement liées aux entiers, telles que la conversion d'une chaîne en entier et définit également des constantes qui représentent les valeurs maximales et minimales des entiers.

*/

Point de connaissance 2 : Explication détaillée de la méthode integer.values()

Pourquoi le premier jugement revient true et le deuxième jugement revient false ? Y a-t-il une différence entre 127 et 128 que je ne connais pas ? (Bien sûr, sauf que 127 est inférieur à 128...)

Aussi, pourquoi le troisième jugement revient-il true?
J'ai lu les réponses à une autre question connexe, mais je ne sais toujours pas quand elles reviennent vraies et pourquoi le deuxième jugement revient false.

Réponse n°1 :

Integer.valueOf(String) a un comportement inhabituel.

valueOf renverra un objet Integer (entier) Lorsque la chaîne en cours de traitement est comprise entre -128 et 127 (limites comprises), l'objet renvoyé est pré-mis en cache. C'est pourquoi l'appel dans la première ligne renvoie true-127

Cet objet entier est mis en cache (donc le même objet est renvoyé deux fois par valueOf) - la deuxième ligne L'appel renvoie <.> car false n'est pas mis en cache, donc chaque appel générera un nouvel objet entier, 128

, donc les deux

objets entiers sont des objets différents. 128

Il est important de savoir que dans la comparaison ci-dessus, ce que vous comparez réellement est la référence d'objet renvoyée par , donc lorsque vous comparez l'objet entier en dehors du cache, l'égalité le jugement ne reviendra pas integer.valueOf, même si vous réussissez true

et que la valeur de

est égale, cela ne servira à rien. (Tout comme valueOf dans la deuxième ligne. Si vous voulez que ce jugement renvoie Integer.valueOf(128)==Integer.valueOf(128)), vous devez utiliser la méthode true. equals()

ne renvoie pas un objet entier, mais un parseInt() Tapez l'élément de base. C'est pourquoi le dernier jugement renvoie int Dans la troisième ligne du jugement, lorsque l'on juge l'égalité, la comparaison réelle est true, 128 == 128

, elle doit donc être égale. >

Parlons d'une petite différence dans la troisième comparaison, qui rend son résultat différent de la deuxième comparaison :

Une conversion unboxing (une conversion lors de la comparaison, qui convertit l'objet en référence à son atome correspondant type) apparaît dans la comparaison sur la troisième ligne car l'opérateur de comparaison utilise

et il y a un type

et un == des deux côtés du signe égal >Référence d'objet. > l'objet renvoyé sur le côté droit du signe égal est ensuite converti en une valeur

avant d'être égal au

int sur le côté gauche. Ainsi, une fois la conversion terminée, vous comparez en fait deux atomes. valeurs entières. Cette conversion est exactement ce à quoi vous vous attendez lorsque vous comparez deux types atomiques, vous finissez donc par comparer Integer est égal à Integer int

Réponse n°2 : Le 128128. La classe

a un cache statique qui stocke 256 objets

spéciaux - chacun correspondant à `-128 et 127 Une valeur entre

Avec ce concept, vous pouvez connaître la différence entre les trois lignes ci-dessus. code.

1	nouvel Integer(123); Integer

显示创建了一个新的Integer对象。

1

1	Integer.parseInt("123");

Integer.parseInt( "123");

int

解析完字符串后返回一个

值。

1	Integer.valueOf("123");

1	Integer.valueOf("123" code>); -128

127

这种然后如果解析的值位于Integer()和

之间，就会从静态缓存中返回对象。如果超出了这个范围，就会调用

方法并将解析的值作为参数传入，得到一个新的对象。

1	Integer.valueOf("127")==Integer.valueOf("127");

现在，让我们看一下问题中的3个表达式。

tbody>

1true

Integer.valueOf("127")==Integer.valueOf("127");Integertrue

上面的表达式返回

1	Integer.valueOf("128")==Integer.valueOf("128");

，因为的值从静态缓存中取了2次，表达式返回了对象与自己比较的结果。因为只有一个Integer对象，所以返回结果为。

1	Integer.valueOf("128")==Integer.valueOf("128"); code>

L'expression ci-dessus renvoie false car aucun tampon statique n'existe pour 128. Ainsi, chaque fois que l'égalité est déterminée, de nouveaux Integer objets seront créés des deux côtés de l'équation. Puisque les deux Integer objets sont différents, == ne reviendra

que lorsque les deux côtés de l'équation

true représentent le même objet. Par conséquent, l’équation ci-dessus renvoie false.

tr>

1

1	Integer.parseInt("128")==Integer.valueOf("128");

Integer.parseInt("128")==Integer .valueOf("128");

int128L'expression ci-dessus compare la Integer valeur int d'origine à gauche avec l'objet Integer nouvellement créé à droite. Mais comme la comparaison entre

et

n'a aucun sens, Java déballera automatiquement Integerintint avant la comparaison, donc le résultat final est la valeur de la comparaison 128 et true entre. Puisque

est égal à lui-même, est renvoyé.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!