integer不是对象吗，问个问题

Question

public class Test { /**
 * @param args
 */
public static void main(String[] args) { Integer integer = 3;
Integer integer2 = integer;

integer++;

System.out.println(integer == integer2);
}}
居然是false，怎么回事？
请教

Answer 1

那既然integer是对象，==应该是true才是啊

Answer 2

这integer++;，4=3吗？你debug下吧。。

Answer 3

好像。。最后的结果是integer=4,integer2=3
不去考虑"=="与"equals"的区别和用法、
4与3能返回true？
。

Answer 4

另外你可以看一下源码，Integer实际的值是private final int value;
也就是说一个Integer对象，它的值是多少就是多少，不会发生改变
所以说integer++这句，实际是integer被赋予了一个新的对象，value是原integer对象的value+1

Answer 5

这点和String也是一样的，String的具体内容是一个final的char数组，即使用+拼接实际也是创建一个新的String对象

Answer 6

jdk1.5支持自动装箱拆箱 比较的时候应该是自动拆箱 按照值比较了吧 
否则对象是不能++的

Answer 7

实际上，Interger对象比较特殊，用==判断是表示值是否相等。不是表示是否是同一个对象。8个基本类型的封装类型都是如此。
而且楼主 你interger++ 了啊！integer==4了。自然和integer2不相等了。
下面是我做的测试
public static void main(String[] args) {        Integer integer = 3;
        Integer integer2 = integer;
        
        integer++;
        System.out.println("integer ="+integer);
        System.out.println("integer2 =" +integer2);
        System.out.println(integer == integer2);
    }
不信你把integer++这行注释掉。这样就为true了

Answer 8

ls也是不对的……你可以试试
Integer integer = new Integer(3);
Integer integer2 = new Integer(3);
System.out.println(integer == integer2);

Answer 9

肯定是false啦,你可以把这两句调换下顺序,结果是true
integer++;
System.out.println(integer == integer2);

Answer 10

Integer和String一样都是不变类。

Answer 11

顶7楼，13楼的不对。
==比较的是对象的引用，在integer++后，由于自动装箱机制，integer指向一个新对象，引用肯定与integer2不相等

Answer 12

那么看下14楼吧……13楼去掉integer++就是integer2=integer;System.out.println(integer == integer2);再怎么样都不可能不是true的
Integer比较的依然是内存地址，首先int i;...Integer integer = i;这样的操作实际调用的是Integer integer = Integer.valueOf(i);,然后在IntegerCache中缓存了-128~127这256个数，valueOf方法会优先去取Cache中的值
所以如果直接用Integer integer = 3;这样的方式去获取，那么实际是从缓存中去取这个值，所以
Integer integer = 3;
Integer integer2 = 3;
System.out.println(integer == integer2);
的结果是true
但如果对这个范围外的值，比如
Integer integer = 223;
Integer integer2 = 223;
System.out.println(integer == integer2);
那么integer和integer2都是要创建一个新的值为223的对象，实际效果就和14楼给出的一样，结果就是false

Answer 13

java封装的基本类型都是final的，值一旦给定就不能更改，只能指向新的对象。

Answer 14

对，java封装的基本类型都是final的，看源码。它跟String一样。

Answer 15

Java 中包装类其实＝＝也是比较值的

Answer 16

我刚特地去看了源码。注意 Integer类型的hashcode方法如下： public int hashCode() {
return value;
    }
这是它的equals方法： public boolean equals(Object obj) {
if (obj instanceof Integer) {
    return value == ((Integer)obj).intValue();
}
return false;
    }
从这2个方法可以看出 Integer对象的比较是判断2个值是否相等，值相等就为true，反之false。这点和其他对象不一样。相似的有String等。
其他不多说了。楼主自己去测试，看看源码就知道了。

Answer 17

hashcode和equals和==判断并不相同的，只是说明用equals判断时比较的是值，==并不是这样，上面也给过例子了

Answer 18

晕。==号不就是判断对象是否相等吗？而JAVA判断对象是否相等不是通过equals和hashcode2个方法么？这2个方法都返回true。就表示这个对象是同一个对象了。所以我说Integer类型比较特殊。这2个方法都是直接拿实际的值value的。所以JAVA判断为同一个对象。。

Answer 19

Integer ***= 数字 调用的是Interger.valueof（数字）.
在127以内的都是池中的，直接用==比较 也是true至于 Interger ** = new Integer（数字）,new是强制开一个新的对象的，用==比较不可能为true

Answer 20

 == 是运算符 直接比较两边的内存地址
 equals是 Object类里面的方法，子类的具体实现看JDK

Answer 21

28楼这么一说 ，我想起来那个String的经典题目了。有池这个概念就好理解多了。

Answer 22

是的 我混淆了。重写equals必须重写hashcode　但和＝＝　是不同的

Answer 23

import java.util.Scanner;public class Test { /**
 * @param args
 */
public static void main(String[] args) { Integer integer1 = 3;
Integer integer2 = 3;
Integer integer3 = new Integer(3);
Integer integer4 = new Integer(3);
Integer integer5 = 566;
Integer integer6 = 566;
Integer integer7 = 566;
Integer integer8 = integer7;
Integer integer9 = 566;
Integer integer10 = integer9;
integer10++;
integer10--;


System.out.println(integer1 == integer2);
System.out.println(integer3 == integer4);
System.out.println(integer5 == integer6);
System.out.println(integer7 == integer8);
System.out.println(integer9 == integer10);


}}
//true
//false
//false
//true
//false自己又试了试，就这样了

Answer 24

哎 直接输出
 System.out.println("integer ="+integer);
        System.out.println("integer2 =" +integer2);
        System.out.println(integer == integer2);
来看看结果不就行了嘛4
3
false

Answer 25

比较对象是比较地址引用 两个新的new出来的 肯定不指向同一个地方 肯定是false
而如果你初始赋值一样的话 则指向了同一个地方 是true
而equals比较的是值是否相等 你用equals比较上面的4和3 应该就是true了 

Answer 26

        System.out.println(integer);
        System.out.println(integer2);
System.out.println(integer == integer2);
System.out.println(integer.equals(integer2));4
3
false
false上机测试才是王道

Answer 27

Integer的equals是比较值
引用类型的==是比较地址;
这里的问出在了++的地方,涉及了自动装箱和拆箱的功能.产生了新的对象.
应该是integer  = Integer.valueOf();有了新的对象.
可以试一下public class Test {    /**
     * @param args
     */
    public static void main(String[] args) {        Integer integer = 3;
        Integer integer2 = integer;
        
        integer++;
        Integer ii = 4;
        System.out.println(integer == integer2);
        System.out.println(integer == ii);
    }}
你会发现后边的是true,所以是使用Integer.valueOf(),因为这个方法返回的是缓存的数组中的对象.Integer i=3;
Integer j=3;
i==j--->true;Integer k=3000;
Integer m=3000;k==m--->false;

Answer 28

integer =4
integer2 =3 怎么可能为true.

Answer 29

public class Test {    /**
     * @param args
     */
    public static void main(String[] args) {        int integer = 3;
        int integer2 = integer;
        
        integer++;
        
        System.out.println(integer == integer2);
    }}Integer 是对象
int 是类型对象比较要用equal
类型比较可以用 ==

Answer 30

[color=#FF0000]fda[/color]fdaf

Answer 31

fdsfsafd

Answer 32

fdsafdsaf

Answer 33

先不说你写的方法是否正确，
JAVA中分 引用类型和基本类型。
而Integer是属于引用类型的，也就是说它和String类型是一个类型的 你觉得用==能比较两个String类型的数据么？

Answer 34

后面有个integer++，这样integer为4,而integer为3，4==3?最后输出当然是false

Answer 35

后面有个integer  ，这样integer为4,而integer2为3，4==3?最后输出当然是false

Answer 36

因为integer保存的是对象地址，进行++后就指向其它对象。而integer2还是指向值为3的那个Integer对象
所以两个不同的对象的地址肯定不等啊！

Answer 37

楼主去网上找找：装箱、折箱操这一点，java是学了 .net 的

Answer 38

因为你用的是== 同时你用的是Integer包装器类，这样比较的就是对象的内存首地址

Answer 39

先看以下代码： Integer a=127;
Integer b=127;
System.out.println(a==b);//true
        
Integer j=128;
Integer i=128;
System.out.println(i==j);//false你一定觉得很奇怪，为什么一个是TRUE，一个是FALSE呢？对于FALSE还比较好理解，不同的对象嘛，地址肯定是不同的结果当然就是FALSE，可为什么会有TRUE呢，是BUG吗！
其实不是，这是JAVA的一个规定！
Java规范指出：特定的基本数据类型一定得被box成相同的不可变的wrapper对象。这些对象会被高速缓存重复使用，并且会被当作一般的对象使用。这些特定的基本数据类型包括：boolean值的true和false、所有的byte值、介于-128至127的short与int的值、以及介于\u0000与\u007F之间的任何一个char。
所以根据规范，TRUE就不足为奇了！！

Answer 40

Integer integer = 3;
        Integer integer2 = integer;
        
        integer++;        int a=4;
        System.out.println(integer == integer2);
        System.out.println(integer == a);//你会发现这个变成true,明白什么了吗？       

Answer 41

public class Test { /**
 * @param args
 */
public static void main(String[] args) {
// TODO Auto-generated method stub
 Integer integer = 3;
        Integer integer2 = integer;
        
        integer++;
        integer2++;//加个一段代码
        
        System.out.println(integer==integer2 );
         }}经测试，结果为true。说明对象对对象的赋值是内存地址和值的赋值，如Integer integer2 = integer;传的不只是值，还有内存地址，你可能要问这怎么可能那，那他们不就变成一个对象了吗？其实java中对象的创建是这样的，临时的对象放在stack（栈）中，然后内存在heap（堆）中分配一个内存地址给stack中的对象，然后stack中的临时对象指向heap中的内存地址。那么本程序中对象的创建如下，因为Integer是对象也体现了它的特殊性，即stack中产生两个临时地址integer和integer2，heap中产生一个内存地址是值为3的内存地址，然后两个临时对象指向它，最后这两个对象在完成自己使命后（指向内存地址）就被垃圾回收了，那么现在integer和integer2是同一个内存地址中对象的不同表示，然后integer++，这时候stack中产生一个integer++的对象，heap中产生一个值为4的内存地址（3+1），然后integer++指向它产生了一个新的内存地址，那么以前值为3的内存地址消失了吗？当然没有，因为以前是有2个对象指向它的，一个是integer（已经不存在了，因为它指向了值为4的内存地址），另一个是integer2（还在），所以它并没有消失。现在integer指向值为4的内存地址，integer2指向值为3的内存地址，那么它们不论是“==”还是“equals”都不会相等。于是这里我用附加的一段代码来让integer2++，那么integer2也就指向了heap中值为4的内存地址，现在integer和integer2不过是同一内存地址的不同表达形式，那么它们不论是“==”还是“equals”都是相等的，因为他们在内存中相等。

Answer 42

赞7楼
Integer int1 = new Integer(11);
//Integer int2 =int1;
Integer int2 = new Integer(11);

System.out.println(int1 == int2 ); //false
System.out.println(int1.equals(int2)); //true

int1++;
System.out.println(int1); //12
System.out.println(int2); //11
System.out.println(int1==int2); //false
System.out.println(int1.equals(int2)); //false

//
int2++;
System.out.println(int1); //12
System.out.println(int2); //12
System.out.println(int1==int2); //true
System.out.println(int1.equals(int2));  //true

Answer 43

这个类比较特殊，就像String一样，他这个是值变，对象就变了，也就是说只要你操作这个对象让他的值变了，实际上相当于他重新new了一次

Answer 44

执行任何算术操作会自动转为int
其中还有自动装箱，其实不用关心这些边角，实在话真没啥用。

Answer 45

4楼的其实已经回答这个问题的正解，但不知为什么到了7楼又混淆了概念。
我们可以做这个实验 Integer i = 3;
Integer j = 3;
Integer x = new Integer(3);
Integer y = new Integer(3);

System.out.println(i == j);
i++;
System.out.println(i == j);
System.out.println(x == y);第一个结果是true，第二个结果是false，第三个结果是false。
是什么原因造成这个结果呢？
我们先从第三个结果看，x和y都是new出来的对象，所以他们的value相等但是
== 的结果是false，这个结论验证了7楼引述的思想。
但是在JDK1.5之后，
增加了自动装箱和拆箱的功能（autoboxing、auto-unboxing），所以我们可以使用
Integer i = 3;这个样的语句来代替Integer x = new Integer(3);（这个是自动装箱）
当然存储的方式还是对象。
相对应的事自动拆箱，（我们就可以直接写i++，这在以前是不行的）。这里JRE会根据
操作符自动将Integer的value取出自增一得到正确的结果，而不会增加内存的地址。同样，在进行i==j的比较的时候就使用了自动拆箱，得出的结果是value的比较结果。
在这个实验中就得到了4 == 3 的结果，出来的是false。
这个就是我们第二个结果第一个结果是true就不用解释了。

Answer 46

7楼并不是混淆概念，而是对拆装箱的一个补充
正是因为7楼所说的原因，才导致需要去自动拆装箱的，否则就像楼主所提的问题那样，我这个Integer对象的value是3，执行++后把value变成4不就得了，对象本身不变，导致==的结果为true
正因为Integer的value是一个final的成员，导致了执行运算操作，不能直接改变对象的value值，只能拆箱用intValue方法取值，然后运算，最后用valueOf方法实现装箱获得一个新的对象

Answer 47

 public static void main(String args[])
    {        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        
        Integer i3 = 128;
        Integer i4 = 128;
        
        Integer i5 = 127;
        Integer i6 = 127;
        
        System.err.println(i1 == i2);
        System.err.println(i3 == i4);
        System.err.println(i5 == i6);
        System.err.println(i1 == i6);
        
    }
这个也很有趣 可以研究下哦

Answer 48

Integer在-128到+127是在常量池中的，请看测试：public class MainFrame{
public static void main(String[] args){
Integer a1 = 127;
Integer b1 = 127;
System.out.print("127==127:");
System.out.println(a1==b1);

Integer a2 = 128;
Integer b2 = 128;
System.out.print("128==128:");
System.out.println(a2==b2);

Integer a4 = -128;
Integer b4 = -128;
System.out.print("-128==-128:");
System.out.println(a4==b4);

Integer a5 = -129;
Integer b5 = -129;
System.out.print("-129==-129:");
System.out.println(a5==b5);
}
}
测试结果为：127==127:true
128==128:false
-128==-128:true
-129==-129:false

Answer 49

integer1==integer2为true  怎么integer5==integer6为false?这太神奇了吧

Answer 50

一。java 中基本类型的包装类与java中的基本类型之间是有一些注意的问题的：
在java中的1.5版本之前是需要这样写的：Integer i=new Integer(10)；但是在java1.5版本之后可以这样写，先看看这样一段代码：
1.Integer i=89;Integer j=89;System.out.println(i==j)//true
2.Integer i=128;Integer j=128;System.out.println(i==j)//false
3.Integer i=129;Integer j=129;System.out.println(i==j)//false
4.Integer i=-128;Integer j=-128;System.out.println(i==j)//true
5.Integer i=-129;Integer j=-129;System.out.println(i==j)//false
这是由于在内存中当整型小于128是且大于等于-128时，Integer使用的存储结构于int的存储结构是一样的；但是在这个范围之外二者的存储结构是不一样的；所以他们输出的结果是不一样的
二。在我们以后使用包装类型的比较二者的大小时就用equal（）比较不容易出错；
三。java中个基本类型的包装类都是final修饰的；
四，上面的代码只要把Integer++去掉就好了；输出结果就为true了；

Answer 51

64楼 和 68楼是正解其实楼主的意思是这样：
先 new 一个 Integer A=3
再 new 一个 Integer B 引用 A，此时B==A应该是true，值为3
然后 B++，此时 B值为4，而因为B引用A，所以A值此时应该也变成4
所以 ，此时 B==A 应该仍然为true回答这个问题的各位大哥，你们应该先回答为什么A此时还是3，不是4
然后问题解决，不是么？A不变的原因，其实7，8，19，38都说到了，不过64 68说的更仔细，更深入