core java有个地方没看懂

Question

Integer a=1000;
Integer b=1000;
System.out.println(a == b);
结果是falseInteger a=100;
Integer b=100;
System.out.println(a == b);
结果是true得出这两个不同结果是详细原因是什么呢

Answer 1

因为缓存机制。
当你所指定的数字范围在-256到255时，会使用缓存中的对象，所以a、b其实是同一对象。
而超出此范围时，会创建新的对象，此时a、b是两个不同的对象。

Answer 2

[接1楼]
Integer a = 100; 
这句代码会产生装箱的操作，装箱的过程是通过Integer.valueOf()方法来完成的，你看一下JDK的源代码，就知道了。呵呵。这个问题在良葛格的《JDK5学习笔记》一书中有论述，如果你刚学Java，建议看看这本书。

Answer 3

经过测试没有出现lz所述效果,两个都是false,lz骗人,5555555555

Answer 4

我机上结果是1true1false
我也不懂,继续关注....

Answer 5

老问题了~因为1.5出来的缓冲池的缘故，所以1.4的版本看不到结果
原因就是1与4楼所说的那样，不懂的话可以先放着，去看看源码或者看看
String类创建对象的机制

Answer 6

在212页讲得还是蛮清楚的：
    As you know, the == operator, applied to wrapper objects, only tests whether the objects have
identical memory locations.The following comparison would therefore probably fail:
    Integer a = 1000;
    Integer b = 1000;
    if (a == b) ...
    However, a Java implementation may, if it chooses, wrap commonly occurring values
into identical objects, and thus the comparison might succeed. This ambiguity is not
what you want. The remedy is to call the equals method when comparing wrapper
objects.NOTE: The autoboxing specification requires that boolean, byte, char  127, and short and
int between –128 and 127 are wrapped into fixed objects. For example, if a and b had been
initialized with 100 in the preceding example, then the comparison would have had to
succeed.

Answer 7

刚才上面的<= 没有显示出来应该是：
     NOTE:......boolean, byte, char <= 127, and short and...... 

Answer 8

哦！是的。我记错byte的数据范围了，呵呵。
应该是-128到127，不好意思。在1楼时说成-256到255了。呵呵。

Answer 9

就是那个NOTE,现在已经知道了,不过还不太清楚为什么要单独弄一个-128-127的cache另外,书下面的问题又说了一个东西,我没看懂....class TT{
public int tt=0;

}public class Test{
public static void add(Integer m){
m+=1;
}

public static void change(TT tt){
tt.tt+=1;
}
public static void main(String[] args)
{
Integer m=0;
add(m);
TT tt=new TT();
change(tt);
System.out.println(m);
System.out.println(tt.tt);
}
}
结果
0
1
书上说Integer类的对象不可以被改变,这个不懂,如果我上面的那个Integer不是在方法之中处理,那么Integer+=1是可以使它从0变成1的,但是放在方法中就不行了.
而自己定义的对象,是可以在方法之中达到修改的目的的

Answer 10

Integer也是类啊,为什么和我自定义的类不一样呢,它很特殊??另外,JAVA里没有运算符重载,那String,Integer对运算符的重载是怎么实现的啊,源代码里怎么样可以看到?

Answer 11

型参和实参虽然不一样,但是它们都是对同一个对象的引用,修改相应的对象之后,所指对象的值应该改变啊,Integer怎么不变呢

Answer 12

你感觉什么地方特殊了？
缓存－１２８到—＋１２７之间的数肯定是这些数用到的概率非常之大，我直接缓存下来比你用到一个就创建一个肯定方便快捷。
Ｓｔｒｉｎｇ是对＋操作符进行重载了，是编译器直接提供支持的，当编译器遇到对Ｓｔｒｉｎｇ的＋的时候会把相应的操作转换为StringBuilder的ａｐｐｅｎｄ操作，最后再转换为String。这样可以避免创建很多的中间String.对于Ｉｎｔｅｇｅｒ，只是碰到＋之后直接取Integer.intValue()把值取出来，作为ｉｎｔ参与运算，也是编译器支持的。需要代码的话要去ｊａｖａｃ的源代码里面找。

Answer 13

对于下面的例子：public class Test {    public static void main(String args[]) {
        Integer i = 1;
        System.out.println(i);
        i+=1;
        System.out.println(i);
    }
}实际执行相当于：　　　Integer i = Integer.valueOf(1);
      System.out.println(i);
      int temp = i.intValue()+1;
      i=Integer.valueOf(temp);  //指向了一个新的对象
      System.out.println(i);

Answer 14

方法内对Ｉｎｔｅｇｅｒ引用的赋值让方法内的引用指向了一个新的Ｉｎｔｅｇｅｒ对象。而方法外的引用没有指向这个新的对象。
注意一个基本的问题，通过＝操作实现的是改变基本类型的值，改变引用类型指向的对象。
如果要改变引用指向的对象的数据，需要通过调用这个类提供的方法，比如StringBuffer调用ａｐｐｅｎｄ方法会把对象的内容改写了

Answer 15

i=Integer.valueOf(temp);  //指向了一个新的对象
原来是这样,陷阱真多......
只是碰到＋之后直接取Integer.intValue()把值取出来，作为ｉｎｔ参与运算
---------------------------
这是javac里的源码?JAVADOC里面可不可以查到相关内容,对于操作符是怎么处理的代码

Answer 16

因为在java虚拟机中，对于String对象是有对象池的，对于Integer对象在小于255时是同一个对象，而大于255时候就会创建新的对象！