java integer =_【java】Integer == Integer？

/**

*Q：Integer和Integer对象用 == 进行比较的过程是怎样的？

*

*看例子

*/

public class Test {

public static void main(String[] args) {

int a = 1;

int b = 1;

Integer c = 3;

Integer d = 3;

Integer e = 321;

Integer f = 321;

System.out.println(a == b);

System.out.println(c == d);

System.out.println(e == f);

}

}

output：

true

true

false

下面具体解释三个结果

通过java命令 javap -c 得到下面的字节码

Compiled from "Test.java"

public class Test extends java.lang.Object{

public Test();

Code:

0: aload_0

1: invokespecial #1; //Method java/lang/Object."":()V

4: return

public static void main(java.lang.String[]);

Code:

0: iconst_1 //将int类型常量1压入栈

1: istore_1 //将int类型值存入局部变量1

2: iconst_1 //将int类型常量1压入栈

3: istore_2 //将int类型值存入局部变量2

4: iconst_3 //将int类型常量3压入栈

5: invokestatic #2; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer; //调用Integer的静态方法 valueOf，构建整型值为3的Integer对象

8: astore_3 //将引用存入局部变量3

9: iconst_3

10: invokestatic #2; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;

13: astore 4

15: sipush 321 //将321压入栈

18: invokestatic #2; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;

21: astore 5

23: sipush 321

26: invokestatic #2; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;

29: astore 6

31: getstatic #3; //Field java/lang/System.out:Ljava/io/PrintStream;

34: iload_1 //从局部变量1中装载int类型值到栈

35: iload_2

36: if_icmpne 43 //从栈中pop出两个int类型值并进行大小比较

39: iconst_1

40: goto 44

43: iconst_0

44: invokevirtual #4; //Method java/io/PrintStream.println:(Z)V

47: getstatic #3; //Field java/lang/System.out:Ljava/io/PrintStream;

50: aload_3 //从局部变量3中装载引用到栈

51: aload 4

53: if_acmpne 60 //从栈中pop出两个引用值进行比较

56: iconst_1

57: goto 61

60: iconst_0

61: invokevirtual #4; //Method java/io/PrintStream.println:(Z)V

64: getstatic #3; //Field java/lang/System.out:Ljava/io/PrintStream;

67: aload 5

69: aload 6

71: if_acmpne 78

74: iconst_1

75: goto 79

78: iconst_0

79: invokevirtual #4; //Method java/io/PrintStream.println:(Z)V

82: return

}

整型值的比较很容易理解，就是值的大小比较

但是为什么下面的语句会是不同的结果：

System.out.println(c == d);

System.out.println(e == f);

从字节码上看都是一样的指令，没有不同的地方

原因就在Integer的方法 valueOf

我们来看这个方法的源码：字节码里调用的就是这个方法：

public static Integer valueOf(int i) {

if(i >= -128 && i <= IntegerCache.high)

return IntegerCache.cache[i + 128];

else

return new Integer(i);

}

private static class IntegerCache {

static final int high;

static final Integer cache[];

static {

final int low = -128;

// high value may be configured by property

int h = 127;

if (integerCacheHighPropValue != null) {

// Use Long.decode here to avoid invoking methods that

// require Integer's autoboxing cache to be initialized

int i = Long.decode(integerCacheHighPropValue).intValue();

i = Math.max(i, 127);

// Maximum array size is Integer.MAX_VALUE

h = Math.min(i, Integer.MAX_VALUE - -low);

}

high = h;

cache = new Integer[(high - low) + 1];

int j = low;

for(int k = 0; k < cache.length; k++)

cache[k] = new Integer(j++);

}

private IntegerCache() {}

}

Integer里弄了一个缓存，对于在 -128—127 之间的数值，会直接使用该缓存里的对象

也就是说 Integer c = 3 或者 Integer c = Integer.valueOf(3) ，最终 c 得到的是Integer里的缓存对象

同理，d也是获得该相同对象因此 进行 c == d 比较时，c和d引用的是同一个对象，因此就true

而对于321，已经超出缓存范围了，因此 valueOf 方法会生成一个新的Integer对象因此e和f就引用不同 的对象了，进行==比较，当然就false了

另外，对Integer的缓存，我们在日常开发时，对于小的整型值应该充分利用Integer的缓存对象省去过多的对象创建，回收的操作，这样会极大的提高程序性能