关于Integer的存储问题

去查下源码或者是java的自动装箱和拆箱对于你这种写法，int型的6会被自动装箱成为Integer对象，而且对于[-128, 127]的int值会进行缓存，所以这里认为是同一对象。Integer i = 128;
Integer j = 128;

System.out.println(i == j);

Integer内部缓存了-128到127共256个Integer对象,Integer i1=6产生一个Integer对象，Integer i2=6会检查缓存中是否有指向6的对象，这个跟String有点类似
如果LZ将上面的值改成-128~127 外的数字，结果就是false

那Integer，或者int，他们的值是放哪的呢，比如 Integer i=3.这个对象放哪？int i=3，这个值放哪？

在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配，当在一段代码块定义一个变量时，Java 就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java 会自动释放掉为该变量分配的内存空间，该内存空间可以立即被另作它用。
内存用来存放由 new 创建的对象和数组，在堆中分配的内存，由 Java 虚拟机的自动垃圾回收器来管理。你是想问这个把？二楼的高手啊。。

Integer 不是简单类型，他应该是放在堆里的，但是，"对于[-128, 127]的int值会进行缓存",这又是怎么实现的呢，我在源代码里无法找到答案。

直接Integer i1= 6 这样初始化是在栈区，new出来的才在堆区，和String一样，直接String str ="aaa" 那么在栈区，如果 String str = new String("aaa");就会在堆区

i1不是已经被自动装箱成Integer对象了吗，那应该是放堆里的，又怎么会是在栈里呢，栈不是只放引用变量和简单类型的吗

String str ="aaa" 在栈区 ? 阁下真会开玩笑.

String str="aaa";//是在String池里面创建了一个"aaa"对象
而String str=new String("aaa");//创建了两个对象,一个在String池里面，还有一个是new出来的，在堆内存中,str是引用,两个对象都是"aaa";
所以关于Integer i1=6应该是先装箱，堆里和栈里都有对象，是创建了两个对象

JVM运行时数据区的内存模型由五部分组成：
方法区，堆，JAVA栈，PC寄存器，本地方法栈
方法区主要存储static类型的变量，常量池，和类中相关方法的一些信息
new 出来的对象都是存储在堆上
方法中的基本数据类型，和引用对象存储在java栈中对于String str = "abc";
abc本身存储在方法区的常量池中，引用对象str存储在java栈中
若是String str = new String("abc");
内存中会有两个abc，一个位于方法区的常量池，一个在堆上，str作为一个引用对象，存储在java栈中

String str = new String("abc");
1.该对象只存在于堆区,常量池中是没有的.
2."str作为一个引用对象，存储在java栈中" 这个说法真确.

new String("abc")创建了两个对象，一个是堆空间上的String对象其内容自然是"abc"，还有一个也是"abc"，这是个无名字符串对象，那么这个对象是存储在哪里呢，也是堆上？

在JAVA中，有六个不同的地方可以存储数据：
1. 寄存器（register）。这是最快的存储区，因为它位于不同于其他存储区的地方——处理器内部。但是寄存器的数量极其有限，所以寄存器由编译器根据需求进行分配。你不能直接控制，也不能在程序中感觉到寄存器存在的任何迹象。
2. 堆栈（stack）。位于通用RAM中，但通过它的“堆栈指针”可以从处理器哪里获得支持。堆栈指针若向下移动，则分配新的内存；若向上移动，则释放那些内存。这是一种快速有效的分配存储方法，仅次于寄存器。创建程序时候，JAVA编译器必须知道存储在堆栈内所有数据的确切大小和生命周期，因为它必须生成相应的代码，以便上下移动堆栈指针。这一约束限制了程序的灵活性，所以虽然某些JAVA数据存储在堆栈中——特别是对象引用，但是JAVA对象不存储其中。
3. 堆（heap）。一种通用性的内存池（也存在于RAM中），用于存放所以的JAVA对象。堆不同于堆栈的好处是：编译器不需要知道要从堆里分配多少存储区域，也不必知道存储的数据在堆里存活多长时间。因此，在堆里分配存储有很大的灵活性。当你需要创建一个对象的时候，只需要new写一行简单的代码，当执行这行代码时，会自动在堆里进行存储分配。当然，为这种灵活性必须要付出相应的代码。用堆进行存储分配比用堆栈进行存储存储需要更多的时间。
4. 静态存储（static storage）。这里的“静态”是指“在固定的位置”。静态存储里存放程序运行时一直存在的数据。你可用关键字static来标识一个对象的特定元素是静态的，但JAVA对象本身从来不会存放在静态存储空间里。
5. 常量存储（constant storage）。常量值通常直接存放在程序代码内部，这样做是安全的，因为它们永远不会被改变。有时，在嵌入式系统中，常量本身会和其他部分分割离开，所以在这种情况下，可以选择将其放在ROM中
6. 非RAM存储。如果数据完全存活于程序之外，那么它可以不受程序的任何控制，在程序没有运行时也可以存在。

堆是一个运行时数据区,类的对象从中分配空间。这些对象通过new建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。java中的对象和数组都存放在堆中。
栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量（,int, short, long, byte, float, double, boolean, char）和对象引用。
栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义：
int a = 3;
int b = 3；
编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找栈中是否有3这个值，如果没找到，就将3存放进来，然后将a指向3。接着处理int b = 3；在创建完b的引用变量后，因为在栈中已经有3这个值，便将b直接指向3。这样，就出现了a与b同时均指向3的情况。这时，如果再令a=4；那么编译器会重新搜索栈中是否有4值，如果没有，则将4存放进来，并令a指向4；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的，因为这种情况a的修改并不会影响到b, 它是由编译器完成的，它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态，会影响到另一个对象引用变量。

下面来举几个例子：
public class TestStr {
  public static void main(String[] args) {
    // 以下两条语句创建了1个对象。"凤山"存储在字符串常量池中
    String str1 = "凤山";
    String str2 = "凤山";
    System.out.println(str1==str2);//true

    //以下两条语句创建了3个对象。"天峨"，存储在字符串常量池中，两个new String()对象存储在堆内存中
    String str3 = new String("天峨");
    String str4 = new String("天峨");
    System.out.println(str3==str4);//false

    //以下两条语句创建了1个对象。9是存储在栈内存中
    int i = 9;
    int j = 9;
    System.out.println(i==j);//true

      //以下两条语句创建了1个对象。1对象存储在栈内存中
    Integer l = 1;//装箱
    Integer k = 1;//装箱
    System.out.println(l==k);//true

    //由于没有了装箱，以下两条语句创建了2个对象。两个1对象存储在堆内存中
    Integer l1 = new Integer(1);
    Integer k1 = new Integer(1);
    System.out.println(l1==k1);//false

    //以下两条语句创建了1个对象。i1,i2变量存储在栈内存中，两个256对象存储在堆内存中
         Integer i1 = 256;
                Integer i2 = 256;
         System.out.println(i1==i2);//false
  }
} 对于以上最后两个关于Integer对象的例子，在自动装箱时对于值从–128到127之间的值，使用一个实例。
下面是对字符串常量池（）的一个例子：
String s1 = "aaa" + "bbb"; //产生了1个对象。
由于常量的值在编译的时候就被确定了。在这里，"aaa"和"bbb"都是常量，因此变量s1 的值在编译时就可以确定。这行代码编译后的效果等同于：
String s1 ="aaabbb";
因此这里只创建了一个对象"aaabbb"，并且它被保存在字符串池里了。

String str1 = "凤山";
String str2 = "凤山";
以上两条语句只在常量池中保存了一个"凤山"对象。

String str3 = new String("天峨");
String str4 = new String("天峨");
以上两条语句创建了3个对象，首先在字符串常量池中创建一个"天峨"对象，接着在堆内存中创建两个new String()对象，里面保存的是指向"天峨"对象的引用。
另：“==“在判断对象时，其实是根据对象在堆栈中的地址判断对象是不是一样，而不是根据hashcode 值。

在网上看见这段对Java String中的HashCode和equal的总结比较好，记录如下：
    1. hashSet中比较是否重复的依据是a.hasCode（）=b.hasCode（） && a.equals（b）
    2. String的hashCode依据：以依赖于char[i]的int值以和char[i]的排列序的算法计算出的（可以去看看源码）。不依赖String的ref.
    3. String的equals依据： a==b || （ a.length=b.length && { a[i]=b[i] } ）
    4. 只有用a==b时比校的才是比校的ref，也就是说这时才是比校是a与b是不是同一个对象
    5. 结论：两个不同ref的String可能会被认为是集合中的同一个元素。
下面分析一个代码示例：
class BirthDate {
        private int day;
        private int month;
        private int year;
        public BirthDate(int d, int m, int y) {
                day = d;
                month = m;
                year = y;
        }
        省略get,set方法
        public void display() {
        System.out.println
                (day + " - " + month + " - " + year);
        }
}

public class Test{
        public static void main(String args[]){
                Test test = new Test();
                int date = 9;
                BirthDate d1= new BirthDate(7,7,1970);
                BirthDate d2= new BirthDate(1,1,2000);
                test.change1(date);
                test.change2(d1);
                test.change3(d2);
                d1.display();
                d2.display();
        }

        public void change1(int i){
        i = 1234;
        }

        public void change2(BirthDate b) {
        b = new BirthDate(22,2,2004);
        }

        public void change3(BirthDate b) {
        b.setDay(22);
        }
}
以下为对内存的分析：

成员变量：方法外部，类的内部定义的变量。
局部变量：方法或语句块内部定义的变量。

new String("abc")只创建了一个String对象,何来两个?你看一下effective java就知道了.举个C语言的例子更简单
char *s = "abc"; "abc"是一个字符串常量.
char s[] = "abc"; "abc"不是常量,只是存在与字符数组中.可见不是出现"abc"就是常量.

引用类型名称不同，但是值相同，值是保存到相同的内存堆中具体，，使用debug调试，，就可以看的出问题了

Integer s=k;实际上是默认调用Integer s=Integer.vauleof(k);如果k的范围在-128-127之间那么s就直接指向栈中的固定对象地址，否则就指向堆里面的变化的对象地址.很显然如果连续创建在-128-127的Integer对象，那么它们的地址肯定都是一样的,反之不一样.不单单是Integer ，所有的包装类都有这个特性,比如说Charter包装类，只要是用Charter创建一个asc码范围在127以内的字符，那么它们地址都是一样的，否则就不一样.道理都是相通的,祝楼主好运。

public static Integer valueOf(int i) {
      final int offset = 128;
      if (i >= -128 && i <= 127) { // must cache
         return IntegerCache.cache[i + offset];
      }
       return new Integer(i);
    }
当你直接给一个Integer对象一个int值的时候，其实他是调用了valueOf这个方法//IntegerCache 是Integer的一个内部类，作用是在第一次调用
//时对-128到-127之间的整数进行装箱，cashe数组时final修饰的
//，因此它是不能改变的变量，其值与第一次调用时的值是一样的
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 = new Integer(i - 128);
}
    }
25楼说的这段
//以下两条语句创建了1个对象。1对象存储在栈内存中
    Integer l = 1;//装箱
    Integer k = 1;//装箱
    System.out.println(l==k);//true 是错误的
其实这两个引用时指向同一个放在堆内存里的对象具体的楼主可以看看Integer的 valueOf(int i)方法

实际上，对于如下范围的简单数据类型：
boolean类型的值
所有byte类型的值
在-128~127之间的short类型的值
在-128~127之间的int类型的值
在\u0000~\u007F之间的char类型的值在进行自动装箱的时候，将会首先检查内存中是否已经有使用自动装箱产生的具有相同值的对象，。
如果已经有一个“值”相同的对象产生，那么并不会产生新的对象。

调试易

关于Integer的存储问题

解决方案 »