Https://www.cnblogs.com/liuling/archive/2013/05/05/intAndInteger.html reimpreso
¿Cuánto sabes sobre la comparación entre Integer e int?
Si el entrevistador pregunta la diferencia entre Integer e int: se estima que la mayoría de las personas solo dirán dos cosas: Ingeter es la clase de empaquetado de int, el valor inicial de int es 0 y el valor inicial de Ingeter es nulo. Pero si el entrevistador pregunta Integer i = 1; int ii = 1; i == ii ¿es verdadero o falso? Se estima que algunas personas no podrán responder, y si le preguntas a otras, se estima que habrá más personas confundidas. Así que los he resumido y espero ayudar a todos.
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
}
}En primer lugar, los resultados de salida de las líneas 17 y 18 son verdaderos, porque las relaciones Integer e int se desempaquetan automáticamente (más de jdk1.5).
El resultado de la línea 22 es verdadero y el resultado de la línea 25 es falso. Muchas personas no se mueven. De hecho, al compilar Integer i5 = 127, java se traduce como-> Integer i5 = Integer.valueOf (127); por lo tanto, la clave es mirar la función valueOf (). Solo mire el código fuente de la función valueOf () para comprender. La función valueOf del código fuente JDK se ve así:
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() {}
}
Mirando el código fuente, todos entenderán que el número entre -128 y 127 se almacenará en caché. Cuando Integer i5 = 127, 127 se almacenará en caché. La próxima vez que se escriba Integer i6 = 127, se tomará directamente del caché. No será nuevo. Entonces el resultado de la línea 22 es verdadero, y la línea 25 es falsa.
Para las líneas 27 y 30, porque los objetos son diferentes, es falso.
Mi resumen de la situación anterior es el siguiente:
①En cualquier caso, Integer y el nuevo número entero no serán iguales. No pasará por el proceso de desempaquetado, los puntos de referencia de i3 al montón e i4 apuntan a su memoria especial (grupo constante), sus direcciones de memoria son diferentes, por lo que es falso
② Ambos son números enteros no nuevos, si el número es Entre 128 y 127, es cierto, de lo contrario es falso.
Al compilar Integer i2 = 128, se traduce a-> Integer i2 = Integer.valueOf (128); y la función valueOf () será -128 a 127 Caché el número entre
③ Ambos son nuevos, ambos son falsos
④ La relación de int e entero (ya sea nuevo o no) es verdadero, porque Integer se desempaquetará automáticamente como int y luego se comparará
Si crees que algo está mal, dale la bienvenida a las instrucciones.
