程序如下，
class autoBox
{
        public static void main(String[] args)
        {
                Integer x=new Integer(127);
                Integer y=new Integer(127);
                System.out.println("x==y:"+(x==y));
               
                Integer a=127;//自动装箱，等价于Integer a=new Integer(127);
                Integer b=127;//自动装箱，等价于Integer b=new Integer(127);
                System.out.println("a==b:"+(a==b));
        }
}
运行结果：x==y:false
                 a==b:true
问题是，对于Integer包装类的事例化对象x和y,当实例化对象的数值在byte范围内时，在JDK1.5版本之后，如果该数值已近存在，则x与y的引用会指向同一个对象，但为什么在程序运行后x和y并没有指向同一个实例化对象，而a和b却指向了同一个实例化对象？

1. class autoBox
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 Integer x=new Integer(127);
   
6.                 Integer y=new Integer(127);
   
7.                 System.out.println("x="+(++x)+"y="+y);
   
8.                
   
9.                 Integer a=127;//自动装箱，等价于Integer a=new Integer(127);
   
10.                 Integer b=127;//自动装箱，等价于Integer b=new Integer(127);
    
11.                 System.out.println("a="+(++a)+"b="+b);
    
12.         }
    
13. }

复制代码

运行一个试试，你会发现你的提问有问题。

new等同于新建对象。xy都使用了new创建了2个新的对象。我是这么理解的！

                 Integer m = 128;
  　　　　 Integer n = 128;
   　　　　sop("m==n : "+(m==n)); // false  因为是两个不同的对象
   

   当数值在byte范围内(-128~127)时，对于新特性，如果该数值已经存在，则不会再开辟新的空间，

　因此，a和b指向同一个Integer对象

   但是，如果是通过 new 出来的对象，还是两个独立的对象

   　　　　Integer i1 = new Integer(127);
　　　　   Integer i2 = new Integer(127);
  　　　　 sop("a==b : "+(a==b)); // false

                 sop("x.equals(y) : "+x.equals(y)); // true    Integer中 equals方法：

                                                                  比较此对象与指定对象。当且仅当参数不为 null，

                                                                  并且是一个与该对象包含相同 int 值的 Integer 对象时，结果为 true。

水竹 发表于 2014-4-26 12:56
运行一个试试，你会发现你的提问有问题。

不太明白你的意思！我初学，多指教！

你为谁归来 发表于 2014-4-26 13:10
new等同于新建对象。xy都使用了new创建了2个新的对象。我是这么理解的！

多谢你的回答！
a与b直接赋值初始化不是也等同于分别new了一个对象，但是赋值内容都在byte范围内时，为什么x与y就指向不同的引用，而a与b则指向同一个应用

yinxjfly 发表于 2014-4-26 13:30
多谢你的回答！
a与b直接赋值初始化不是也等同于分别new了一个对象，但是赋值内容都在byte范围内时，为什 ...

SORRY，我没说清楚。我附加一段代码给你看下。

1. public class Demo6
   
2. {
   
3.         public static void main(String[] args)
   
4.         {                       
   
5.             Integer x=new Integer(127);          
   
6.         Integer y=new Integer(127);
   
7.         System.out.println(x.equals(y));           
   
8.         System.out.println("x==y:"+(x==y));        
   
9.         Integer a=127;//自动装箱，等价于Integer a=new Integer(127);        
   
10.         Integer b=127;//自动装箱，等价于Integer b=new Integer(127);
    
11.         System.out.println(a.equals(b));
    
12.         System.out.println("a==b:"+(a==b));
    
13.         }
    
14. }
    

复制代码

结果：
true
x==y:false
true
a==b:true
虽然Integer i = 100;  相当于编译器自动作的语法编译：Integer i = new Integer(100);
但是当不使用自动装箱功能的时候，情况与普通类对象一样。new2次就是2个对象。他们的地址值
是不一样的。但是你使用了自动装箱操作就一样的了。最后给你了博客http://www.cnblogs.com/danne823/archive/2011/04/22/2025332.html
你自己看下就知道了，上面说的比较清楚了！呵呵！

你为谁归来 发表于 2014-4-26 23:47
SORRY，我没说清楚。我附加一段代码给你看下。

结果：

多谢多谢！这个问题困扰我好几天了！:handshake