class IntegerDemo2{
    public static void main(String[] args){
        //Integer x = new Integer(4);
        Integer x = 4; //自动装箱，4是一个对象，相当于 new Integer(4)
        x = x + 2;  //x+2: x进行了自动拆箱，变成了int类型，和2进行加法运算，再将和进行装箱赋给x。
                //自动拆箱：x.intValue();

    }
     
    public static void sop(Object obj){
        System.out.println(obj);
    }
     
}

上面代码中，
Integer  x = 4;
x = x + 2;   之后，内存中是不是存在了两个Integer对象？
因为，x+2  后是不是多了个值为6的Integer对象？ 然后把这个新对象的地址值赋给了x，原来值为4的Integer对象就没被引用了？

还是说原来值为4的Integer对象的内容变成了6，而自始至终还是只有这一个对象？
java对象包装类Integer

应该是把原来的X给覆盖了，原来的Integet(4)没有对象指向了，会被回收

你可以这样测试 Integer y = x+2;
System.out.println（x==y）；

享元模式的具体过程：
如果一个int类型的数据在 -128~127 之间（即一个字节），当把它包装成一个Integer类型时，会把这个数据放在一个缓冲池中，在下次把同一个数据包装成Integer类型时，就直接去缓冲池中拿，这就是设计模式中的“享元模式”。
看下面的代码：

1. public class IntegerTest {
   
2.     public static void main(String[] args) {
   
3.        Integer integer1 = 127;
   
4.        Integer integer2 = 127;
   
5.        Integer integer3 = 128;
   
6.        Integer integer4 = 128;
   
7.        System.out.println(integer1 == integer2);
   
8.        System.out.println(integer3 == integer4);
   
9.     }
   
10. }
    

复制代码

integer2与integer1拿到的是同一个对象，对应的当然是同一个地址，因此打印结果为true。

Integer integer3 = 128;   会新建一个对象，假设对象的地址是address3，对象内容是128
Integer integer4 = 128;   也会新建一个对象，假设对象的地址是address4,对象内容也是128
因为 “integer3 == integer4” 比较的是两个对象的地址而不是对象的内容，显然地址是不一样的，因此返回false。

再来看你的代码：

1. class IntegerDemo2{
   
2.     public static void main(String[] args){
   
3.         //Integer x = new Integer(4);
   
4.         Integer x = 4; //自动装箱，4是一个对象，相当于 new Integer(4)
   
5.         x = x + 2;  //x+2: x进行了自动拆箱，变成了int类型，和2进行加法运算，再将和进行装箱赋给x。
   
6.                 //自动拆箱：x.intValue();
   
7. 
   
8.     }
   
9.      
   
10.     public static void sop(Object obj){
    
11.         System.out.println(obj);
    
12.     }
    
13.      
    
14. }

复制代码

根据开头的描述，执行此句时Integer x = 4;先将4包装成Integer类型，然后将它放入缓冲池。此时堆内存中有一个对象 4
x = x + 2; 自动拆箱，运算，将运算结果6自动装箱，装箱后也将6放入缓冲池。这个过程中，先创建一个对象2，然后运算，重新创建一个对象6。最后x断开指向4的引用，转而指向6。


因此堆内存中有3个对象：2、4、6,但是2,4由于没有被指向，所以成了垃圾，
而缓冲池中有两个对象分别是4,6。
以上是《赵晓海》同学的精彩回答。就在云七版。
地址~~~自己去找！！！！

FFF 发表于 2013-11-17 15:56
享元模式的具体过程：
如果一个int类型的数据在 -128~127 之间（即一个字节），当把它包装成一个Integer类 ...

你不是说2，4都垃圾了吗，怎么池里还有4呢。

不是，最近怎么提问回答都不咋给分了呢，这是趋势吗？