关于封装类如Integer的问题

Question

Integer i=10;
如此用Integer构造了已经对象i，并赋值10.那么这个i就是对一个Integer对象的引用，如果我们这样i=20,改变了i的值，那么其实我们是重新构造了一个Integer对象，并赋值20，然后用i引用，原来的那个值为10的对象，其实还是存在的，只是缺少引用。我这样说对吗？

Answer 1

这时需要分析下 垃圾回收吧   
我觉得这是jvm还分辨不出这是个垃圾对象！！
只有在一定的条件下会被回收！这时应该是存在的额个人观点 

Answer 2

String 和 Integer都是final类，一旦创建就无法更改

Answer 3

public static void main(String[] args)
{
Integer i=10;
Integer j=i;
System.out.println(i==j);
System.out.println(i+"--"+j);
j=20;
System.out.println(i==j);
System.out.println(i+"--"+j);
}
试试就知道了。

Answer 4

Integer类在-128-127范围内和String是一样的,超过这个范围就不是了。

Answer 5

把楼上的代码稍微改了下，发现一个有趣的东西
public static void main(String[] args) {
Integer i=10;
        Integer j=i;
        System.out.println(i==j);
        System.out.println(i+"--"+j);
        j=20;
        j=10;
        System.out.println(i==j);
        System.out.println(i+"--"+j); }
输出
true
10--10
true
10--10也就是说，但我将j赋值一定新的值为20的对象后，在又赋值一个10的对象，其实系统并没有真正的再建一个值为10的对象，而只是重新将j的引用指向i引用的那个对象。

Answer 6

int 只是单纯的内存地址引用.. 你的内存地址可变吗?

Answer 7

也就是说，如果两个Integer，如果他们的值相同的话，他们其实是同一个对象，这么说对吗？

Answer 8

public static void main(String[] args) { 
Integer i=150; 
        Integer j=i; 
        System.out.println(i==j); 
        System.out.println(i+"--"+j); 
        j=150; 
        //j=10; 
        System.out.println(i==j); 
        System.out.println(i+"--"+j); }lz这样试一下就知道了,创建了一个对象的,后面加j=10的话,因为前面创建了值为10的Integer对象,对象池中已经有了,就会去对象池中的引用。在-128-127范围外就不会从对象池中取。

Answer 9

看看Integer的源码就知道，在-128到127之间的int值都是放在IntegerCache的缓存中，所以不会新创建对象，你对j赋值一个1111111试试

Answer 10

原理和string的内存池一样，这个一直在内存池中，并没有新建对象，地址还是一样的。
不管多少个10，他们都指向同一个内存池中的地址。

Answer 11

 private static class IntegerCache {
private IntegerCache(){} static final Integer cache[] = new Integer[-(-128) + 127 + 1]; static {
    for(int i = 0; i < cache.length; i++)
cache[i] = new Integer(i - 128);
}
    }
大侠，你是指这段吗，老实说，功力不够，看不懂。

Answer 12

string是final类型；integer是引用类型，如果像Integer integer1 = 10,这样的话，它是放在常量池中，属于栈内存中吧，因为是在常量池中，所以里面只有一个integer1，无法你怎么改变这个值，最后一次的赋值就是integer1的值；如果是Integer integer2 = new Integer(10)的话，这是创建了一个对象了，integer2不会放入常量池中，他将会放入堆内存中，所以只要你new了一个对象出来的话，地址就永远不会相等。

Answer 13

 
Integer在-128  到127的范围使用的是简单int型,,超过了才才是创建的对象!

Answer 14

这个，Integer i=10;
与    Integer i=new Integer(10);有区别吗，java现在不是说自动装箱了吗？

Answer 15

这是引用的道理，非常明确的。
引用被改变，原先被引用的那块就置成null，等着gc()来拖了。

Answer 16

其实在18楼的时候你自己不是把这段代码贴出来了吗？
private static class IntegerCache {
private IntegerCache(){}static final Integer cache[] = new Integer[-(-128) + 127 + 1];static {
    for(int i = 0; i < cache.length; i++)
cache[i] = new Integer(i - 128);
}
    } 
其实还应该把这段代码加进去就明白了：
public static Integer valueOf(int i) {
    final int offset = 128;
    if (i >= -128 && i <= 127) { 
        return IntegerCache.cache[i + offset];
    }
        return new Integer(i);
    }
所有的奥秘都在这里面了。下面我帮你解释一下这段代码吧。不过我不敢保证解释得完全对，让大家来拍砖吧。
楼主说得对，java现在是通过jvm来自动装箱的。但jvm实际上是自动调用的valueOf（）这个方法。很明显，Integer e= 10其实就是Integer.valueOf(10)，也就是说在-128到127都被静态化了，静态化的变量地址是不变的。所以Integer e = 10与Integer f = 10;System.out.println(e==f);这个肯定为true的。
但是当你Integer g = 128时，也就是说不在-128到127这个静态化范围之外时，他会怎样呢？请看代码：
public static Integer valueOf(int i) {
    final int offset = 128;
    if (i >= -128 && i <= 127) { 
        return IntegerCache.cache[i + offset];
    }
        return new Integer(i);
    }
它实际上是return new Integer(i)，它new了一个对象，我们知道Integer是引用类型，在里面重新new了一次，等于又会重新返回一个引用，所以地址也被改变了。
举个简单的例子：
Integer h=128;Integer i=128;system.out.println(h==i);这个会为true吗？肯定不对，因为它们在里面重新new了一次，等于又会重新返回一个引用，所以地址被改变了。也就是说这是两个不同的引用，两个不同的地址。表达能力不行，不知道这样大家明不明白。