Https://www.cnblogs.com/liuling/archive/2013/05/05/intAndInteger.html réimprimé
Que savez-vous de la comparaison entre Integer et int?
Si l'intervieweur demande la différence entre Integer et int: On estime que la plupart des gens ne diront que deux choses. Ingeter est la classe d'emballage de int, la valeur initiale de int est 0 et la valeur initiale de Ingeter est nulle. Mais si l'intervieweur demande Entier i = 1; int ii = 1; i == ii est vrai ou faux? On estime que certaines personnes ne seront pas en mesure de répondre. Si vous demandez à d'autres, on estime que davantage de personnes seront confuses. Je les ai donc résumés et j'espère aider tout le monde.
package com.test;
public class TestInteger {
/**
* @param args
*/
public static void main(String[] args) {
int i = 128;
Integer i2 = 128;
Integer i3 = new Integer(128);
//Integer会自动拆箱为int，所以为true
System.out.println(i == i2);
System.out.println(i == i3);
System.out.println("**************");
Integer i5 = 127;//java在编译的时候,被翻译成-> Integer i5 = Integer.valueOf(127);
Integer i6 = 127;
System.out.println(i5 == i6);//true
/*Integer i5 = 128;
Integer i6 = 128;
System.out.println(i5 == i6);//false
*/ Integer ii5 = new Integer(127);
System.out.println(i5 == ii5); //false
Integer i7 = new Integer(128);
Integer i8 = new Integer(123);
System.out.println(i7 == i8); //false
}
}Tout d'abord, les résultats de sortie des lignes 17 et 18 sont tous deux vrais, car les ratios Integer et int sont automatiquement non encadrés (plus que jdk1.5).
Le résultat de la ligne 22 est vrai et le résultat de la ligne 25 est faux. Beaucoup de gens ne bougent pas. En fait, lors de la compilation d'Integer i5 = 127, java est traduit par-> Integer i5 = Integer.valueOf (127); donc la clé est de regarder la fonction valueOf (). Regardez simplement le code source de la fonction valueOf () pour comprendre. La fonction valueOf du code source JDK ressemble à ceci:
public static Integer valueOf(int i) {
assert IntegerCache.high >= 127;
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}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() {}
}
En regardant le code source, tout le monde comprendra que le nombre compris entre -128 et 127 sera mis en cache. Lorsque Integer i5 = 127, 127 sera mis en cache. La prochaine fois que Integer i6 = 127 sera écrit, il sera extrait directement du cache. , Ce ne sera pas nouveau. Le résultat de la ligne 22 est donc vrai et la ligne 25 est fausse.
Pour les lignes 27 et 30, parce que les objets sont différents, c'est faux.
Mon résumé de la situation ci-dessus est le suivant:
① Dans tous les cas, Integer et new Integer ne seront pas égaux. Ne passera pas par le processus de déballage, les points de référence d'i3 vers le tas et i4 vers sa mémoire spéciale (pool constant), leurs adresses de mémoire sont différentes, donc c'est faux
② Les deux sont des entiers non nouveaux, si le nombre est Entre 128 et 127, c'est vrai, sinon c'est faux.
Lors de la compilation de Integer i2 = 128, il est traduit en-> Integer i2 = Integer.valueOf (128); et la fonction valueOf () sera de -128 à 127 Mettre en cache le nombre entre
③ Les deux sont nouveaux, les deux sont faux
④ Le rapport entre int et entier (qu'il soit nouveau ou non) est vrai, car Integer sera automatiquement déballé en tant qu'int puis comparé
Si vous pensez que quelque chose ne va pas, bienvenue les instructions.
