[code=java]public class demo1 {

        public static void main(String[] args) {
                // TODO Auto-generated method stub
                Integer a = 1024;
                Integer b = 1024;
                Integer c = 1;
                Integer d = 1;
                System.out.println("a==b : " + (a == b));
                System.out.println("c==d : " + (c == d));

        }

}public class demo1 {

        public static void main(String[] args) {
                // TODO Auto-generated method stub
                Integer a = 1024;
                Integer b = 1024;
                Integer c = 1;
                Integer d = 1;
                System.out.println("a==b : " + (a == b));
                System.out.println("c==d : " + (c == d));

        }

}[/code]运行结果为[code=java]a==b : false
c==d : true[/code]我的问题是why？

:) 去查下源码或者是java的自动装箱和拆箱
1、对于你这种写法，int型的的值为1会被自动装箱成为Integer对象，而且对于[-128, 127]的int值会进行缓存，所以这里认为是同一对象。这个也就是在张老师的Java高薪视频里面介绍的一个模式--享元模式
2、而对于[-128, 127]之外的值会重新创建对象，所以不是同一个对象 ，比较会得出false；

也就是说、上诉1所用的的其实就是通过缓存得到，并非重新创建对象如下代码一样[code=java]public class TestIntegerCache
{
        public static void main(String[] args)
        {
                //生成新的Integer对象
                Integer in1 = new Integer(6);
                //生成新的Integer对象，并缓存该对象
                Integer in2 = Integer.valueOf(6);
                //直接从缓存中取出Ineger对象
                Integer in3 = Integer.valueOf(6);
                //输出false
                System.out.println(in1 == in2);
                //输出true
                System.out.println(in2 == in3);
        }
}[/code]
[ 本帖最后由 詹季春 于 2011-07-25  01:56 编辑 ]

对于基本数据类型的包装: Integer integer=new Integer(1)  等同于 Integer integer=1(这就是jdk1.5提供的自动装箱功能);
正如楼上同学所说的那样应特别注意-128--127之间的数据JDK将它封装成对象存放在Cache数组中。

这是JDK1.5的新特性装箱和拆箱，-128--127之间相同的数会被自动装成同一个对象，超出这个范围的数装成的就不是同一个对象了。这就是所谓的享元模式。
享元模式(flyweight)的定义为：采用一个共享来避免大量拥有相同内容对象的开销。这种开销中最常见、直观的就是内存的损耗。享元模式以共享的方式高效的支持大量的细粒度对象。[code]package cn.itcast.day1;
public class AutoBox {
        public static void main(String[] args) {
                Integer iObj=3;//自动装箱
                System.out.println(iObj+12);//自动拆箱
                Integer i1=13;
                Integer i2=13;
                Integer i3=130;
                Integer i4=130;
                System.out.println(i1==i2);//结果为true
                System.out.println(i3==i4);//结果为false
                //调用Integer的静态方法valueOf()将int类型转换为Integer类型
                Integer i5=Integer.valueOf(213);
                Integer i6=Integer.valueOf(213);
                Integer i7=Integer.valueOf(13);
                Integer i8=Integer.valueOf(13);
                System.out.println(i5==i6);//结果为false
                System.out.println(i7==i8);//结果为true
        }
}[/code]

楼上正解，高新视频早就讲过，自己不认真看

这个是内存溢出问题！
一个Integer  存储的是一个字节的东西，一个字节只能在 -128--127之间的整数！

如果超出这个的话，就会溢出，例如
128-------1
129-------2

我查了下。是Integer.indexOf()的 缓存机制问题