今天上课遇到的问题
  Integer i3 = 127;
  Integer i4 = 127;
  System.out.println(i3 == i4);//true
Why?

对于基本数据类型对象，如果在一个字节之内，i3 、i4这俩引用指向的是同一个对象。。。是不会再开辟空间new对象的，太浪费资源，搞一个就好，省事儿

Integer i3 = 127;
Integer i4 = 127;
这两条语句已经包含了自动装箱功能调用了Integer中的valueOf(int i)方法，即变成了Integer i3=Integer.valueOf(127);而查阅了API，以下代码可以看看

1. public static Integer valueOf(int i) {
   
2.         assert IntegerCache.high >= 127;
   
3.         if (i >= IntegerCache.low && i <= IntegerCache.high)
   
4.             return IntegerCache.cache[i + (-IntegerCache.low)];
   
5.         return new Integer(i);
   
6.     }

复制代码

显然，传入的i会先进行判断，是否在某一范围内。再找找那个内部类IntegerCache，代码如下：

1. private static class IntegerCache {
   
2.         static final int low = -128;
   
3.         static final int high;
   
4.         static final Integer cache[];
   
5. 
   
6.         static {
   
7.             // high value may be configured by property
   
8.             int h = 127;
   
9.             String integerCacheHighPropValue =
   
10.                 sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
    
11.             if (integerCacheHighPropValue != null) {
    
12.                 int i = parseInt(integerCacheHighPropValue);
    
13.                 i = Math.max(i, 127);
    
14.                 // Maximum array size is Integer.MAX_VALUE
    
15.                 h = Math.min(i, Integer.MAX_VALUE - (-low));
    
16.             }
    
17.             high = h;
    
18. 
    
19.             cache = new Integer[(high - low) + 1];
    
20.             int j = low;
    
21.             for(int k = 0; k < cache.length; k++)
    
22.                 cache[k] = new Integer(j++);
    
23.         }
    
24. 
    
25.         private IntegerCache() {}
    
26.     }

复制代码

显然，在-128到127的范围内，以上两条语句其实并没有new对象出来，而是共享了同一个引用。
可以试试
Integer i5=new Integer(127);
Integer i6=new Integer(127);
System.out.println(i5==i6);结果是false。

Interger是一个封装类，他会自动装箱，变成一个对象，所以这里的i3和i4都是指向了同一个对象127，==比较引用类型时，永远比较的是地址值，所以结果为true

你在哪里上课呢

-127到+128内的都不生成实例的

lishuliang28 发表于 2015-2-5 21:43
你在哪里上课呢

中腾大厦

烟雾绕 发表于 2015-2-6 00:23
中腾大厦

嗯呢！！！！！1

你把一个改成128就false了，哈哈

三楼解答的比较详细，三楼说得对

Integer i3 = 127;     Integer i4 = 127;
这两条语句并没有new对象出来，引用了同一个内存地址。

哈，楼上图片很生动。

1. Integer i = new Integer(127);
   
2. 源代码：
   
3. public static Integer valueOf(int i) {
   
4.         if (i >= IntegerCache.low && i <= IntegerCache.high)//如果i>-128&&i<=127
   
5.             return IntegerCache.cache[i + (-IntegerCache.low)];
   
6.         return new Integer(i);//超过了127或者小于-128
   
7. 
   
8.         /*
   
9.         ntegerCache.low:-128
   
10.         IntegerCache.high:127       
    
11.        
    
12.         //是一个数组,静态修饰
    
13.         static final Integer cache[];
    
14.        
    
15.         //给这个数组赋值
    
16.         int j = low;
    
17.         for(int k = 0; k < cache.length; k++)
    
18.             cache[k] = new Integer(j++);
    
19.         //该数组在类加载时就已经对每一个值赋值了，范围是-128，127，因为cache是由static修饰所以在这个范围内都是同一个对象
    
20.         //超过了127或者小于-128，返回new Integer(i);这是新的对象了，所以才有
    
21. 
    
22. 
    
23. Integer i1 = 127;
    
24. Integer i2 = 127;
    
25. System.out.println(i1.equals(i2));//true
    
26. System.out.println(i1==i2);//true
    
27. 以上是对这两个结果的源码解释
    
28.         */
    
29. }

复制代码

新特性，享元模式。

学习下。不错