首页 > 试题广场 >

Consider the following code,Wh

[不定项选择题]
Consider the following code: 
Integer s=new Integer(9);
Integer t=new Integer(9);
Long u=new Long(9);
Which test would return true? 
  • (s==u)
  • (s==t)
  • (s.equals(t))
  • (s.equals(9))
  • (s.equals(new Integer(9))
添加回答
推荐
StrongYoung头像 StrongYoung

(s==u) ，因为， s 是 Integer 类型， u 是 Long 类型，两个不同类型的引用不能进行 == 比较。

 

(s==t) ， s 是指向一个 9 的引用，而 t 也是一个指向 9 的引用，虽然都是指向 9 ，但却是指向不同的 9 ，即是两个不同的引用。因此 == 比较返回的是假。

 

(s.equals(t)) ， Integer 的 equals 方法如下：

    public boolean equals(Object obj) {

        if (obj instanceof Integer) {

            return value == ((Integer)obj).intValue();

        }

        return false ;

}

是 Integer 的实例且 value 值也相等的情况下返回真，其他返回假。

在这里， s 和 t 都是 Integer 类型且值都为 9 ，因此结果为真。

 

(s.equals(9)) , 在进行 equals 比较之前，会对 9 调用 Integer.valueOf 方法，进行自动装箱 , 由于 IntegerCache 中已经存在 9 ，所以，直接返回其引用，引用相同， equals 就自然相同了。所以结果为真。

 

(s.equals( new Integer(9)) ，直接创建了一个新的 Integer 实例，但且值也为 9 ，所以，满足条件，返回真。

编辑于 2016-08-25 09:00:20 回复(17)
粉色小蕾丝头像 粉色小蕾丝
  • int和int之间，用==比较，肯定为true。基本数据类型没有equals方法
  • int和Integer比较，Integer会自动拆箱，== 和 equals都肯定为true
  • int和new Integer比较，Integer会自动拆箱，调用intValue方法, 所以 == 和 equals都肯定为true

  • Integer和Integer比较的时候，由于直接赋值的话会进行自动的装箱。所以当值在[-128,127]中的时候，由于值缓存在IntegerCache中，那么当赋值在这个区间的时候，不会创建新的Integer对象，而是直接从缓存中获取已经创建好的Integer对象。而当大于这个区间的时候，会直接new Integer。
    当Integer和Integer进行==比较的时候，在[-128,127]区间的时候，为true。不在这个区间，则为false
    当Integer和Integer进行equals比较的时候，由于Integer的equals方法进行了重写，比较的是内容，所以为true

  • Integer和new Integer ： new Integer会创建对象，存储在堆中。而Integer在[-128,127]中，从缓存中取，否则会new Integer.
    所以 Integer和new Integer 进行==比较的话，肯定为false ; Integer和new Integer 进行equals比较的话，肯定为true

  • new Integer和new Integer进行==比较的时候，肯定为false ; 进行equals比较的时候，肯定为true
    原因是new的时候，会在堆中创建对象，分配的地址不同，==比较的是内存地址，所以肯定不同

  • 装箱过程是通过调用包装器的valueOf方法实现的
    拆箱过程是通过调用包装器的xxxValue方法实现的（xxx表示对应的基本数据类型）

  • 总结：Byte、Short、Integer、Long这几个类的valueOf方法实现类似的。所以在[-128,127]区间内，==比较的时候，值总是相等的（指向的是同一对象），在这个区间外是不等的。
    而Float和Double则不相等， Boolean的值总是相等的

编辑于 2017-10-16 14:32:43 回复(35)
尐V头像 尐V
求解：基本类型和包装类是不是不管在“==”还是equals()中只要满足条件就会自动封装/拆箱？
发表于 2016-10-30 00:17:37 回复(0)
mlc头像 mlc
答案出错了，应该是CDE
发表于 2015-04-17 10:32:04 回复(2)
codingguy头像 codingguy
我觉得有必要提一下，下面这个题目。 
Integer a = 1000, b = 1000; 
System.out.println(a == b);//1 false
Integer c = 100, d = 100; 
System.out.println(c == d);//2 true

Integer a = 1000  它的内部就是这样的：   Integer i = Integer.valueOf(100);
而valueOf方法内部会去取缓存（默认范围 [-128, 127]） ，不会创建新对象。

编辑于 2017-02-25 11:16:09 回复(25)
XQ头像 XQ
CDE
基本类型、对象引用都在栈中；而对象本身在堆中
== 基本数据类型比较的是值 对象比较的是地址 
基本数据类型与封装类比较会自动拆箱，所以比较的还是值，两个封装类比较的是地址

Equals 比较值

发表于 2015-09-03 14:23:34 回复(0)
CodingEnding头像 CodingEnding
关于s==t，添加一点说明：
当Integer的值在-128~127之间时，使用以下两种方式创建Integer对象： 
(1)Integer i=9; (2)Integer j=Integer.valueOf(9);
得到的对象使用==会得到true结果，而使用new Integer()方式创建的对象则会得到false结果。当Integer的值不在这个范围内时，无论以何种方式创建两个Integer对象，使用==都会是false。

编辑于 2017-02-19 00:57:48 回复(2)
请叫我猿叔叔头像 请叫我猿叔叔
发表于 2016-07-19 22:55:25 回复(1)
风屿alter头像 风屿alter 
Integer类重写了equals方法，比较值
发表于 2016-01-02 13:43:40 回复(0)
施振兴头像 施振兴
C、D、E
==默认比较的是对象或者变量所存储的地址，equals方法则可以则继承的类里重写，包装类中的equals实际比较的是所存储的变量值，而对象直接用==则比较的是地址，D中涉及到了自动装箱
发表于 2015-02-13 13:48:04 回复(0)
梅毒菊花茶头像 梅毒菊花茶
  1. s == u 不能编译 具体看Equality Operators
    不是同一类型必然不可能相等，编译时就检查出来了。
  2. s == t 并不是同一个对象，从而是false。
    值得注意的是如果改成
         Integer s = 9;
     Integer t = 9;
    则s == t是true
    并且new Integer(int)是已经废弃了方法。
    但是如 @ghui 所提醒的，只在[-128, 127]范围内会缓存。
  3. 接下来是equals知识点，Integer equals源码:
     /**
  * Compares this object to the specified object.  The result is
  * {@code true} if and only if the argument is not
  * {@code null} and is an {@code Integer} object that
  * contains the same {@code int} value as this object.
  *
  * @param   obj   the object to compare with.
  * @return  {@code true} if the objects are the same;
  *          {@code false} otherwise.
  */
 public boolean equals(Object obj) {
     if (obj instanceof Integer) {
         return value == ((Integer)obj).intValue();
     }
     return false;
 }
    不是同一类型就是false
    因为9自动装箱了，所有还是true
发表于 2018-06-08 09:06:51 回复(0)
大漠苍鹰头像 大漠苍鹰
正确答案为C、D、E。
equals方法比较的是“内容”，即先将对象进行toString得到字符串，然后进行字符串的equals比较。因此，只要内容是9的同类对象Integer，使用equals的结果均为true；
对于A和B，他们比较的是双方的引用而不是内容，因此他们的引用地址肯定不是同一个，不然就是同一个对象了。
发表于 2015-02-12 22:32:27 回复(2)
lpstart头像 lpstart
我觉的正确答案应该是BCDE。CDE 没有疑问。至于B选项，由于java的装箱有缓存，int型的装箱类初始就缓存了-128~127之间的Integer，所以B应该是正确的。
发表于 2016-08-11 09:27:06 回复(3)
ThinkingOverflow头像 ThinkingOverflow
做了无数这种题之后，总结一下，应该算比较全了：
1）如下，直接创建对象 
Integer a = 1000, b = 1000; 
System.out.println(a == b);//1 false
Integer c = 100, d = 100; 
System.out.println(c == d);//2 true
Integer a = 100 它的内部就是这样的： Integer i = Integer.valueOf(100);
而valueOf方法内部会去取缓存（默认范围 [-128, 127]） ，不会创建新对象。

2）而对于new创建对象 
Integer a = new Integer(1000); 
Integer b = new Integer(1000); 
System.out.println(a == b);//1 false

Integer c = new Integer(100);
Integer d = new Integer(100); 
System.out.println(c == d);//2 false
对于new创建Integer对象，每次都会在堆中创建一个新的对象，而不会去缓存取，因此每次创建的对象地址都不同。

3）Byte、Short、Integer、Long这几个类的valueOf方法实现类似的，所以在[-128,127]区间内，直接创建对象（既Integer a=XXX模式），最后都会从缓存中获取值，地址也是相同，既==比较结果相同，如果不是在这个范围之内，则是新创建的对象；而new创建对象的时候，不管值取多少，都是创建新的对象。
当然，不同类型的对象，使用 == 比较结果肯定不同，不管他们值是否相同！

4）对于特殊情况，基本数据类型与包装类比较 
int i=0;
Integer j = new Integer(0);
System.out.println(i=j);//true
System.out.println(j.equals(i));//true
System.out.println(i.equals(j));//编译错误，因为基本数据类型i没有equals()方法
基本型和基本型包装类进行“==”运算符的比较，基本型包装类将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；

5）对于包装类与其他实体类，equals() 方法比较的是对象的内容，==比较地址；对于基本数据类型，没有equals()方法，==比较值



编辑于 2020-04-14 02:50:19 回复(0)
鞋子特大号201909040839250头像 鞋子特大号201909040839250
发表于 2020-03-21 21:57:21 回复(0)
HW柯可头像 HW柯可

直接创建对象和IntegerCache缓存没有关系，自动装箱才和IntegerCache缓存有关！

Cache to support the object identity semantics of autoboxing for values between -128 and 127 (inclusive) as required by JLS.
IntegerCache缓存支持的是值范围为-128~127的自动装箱，用于提升性能和节省内存，也就是说这个范围内的自动装箱（相当于调用valueOf(int i)方法）的数字都会从缓存中获取（这个缓存其实就是用一个Integer类型数组实现的），返回同一个Integer缓存对象.IntegerCache缓存源码：


Integer 的 equals 方法源码如下：

是Integer实例对象且value值相等，才返回true；否则返回false. 
public class IntegerTest {
    public static void main(String args[]){
        Integer s1=new Integer(9);   //直接创建对象
        Integer t1=new Integer(9);   //直接创建对象

        Integer s2=new Integer(128);  //直接创建对象
        Integer t2=new Integer(128);  //直接创建对象

        Integer a1 = 9;   //自动装箱
        Integer b1 = 9;   //自动装箱

        Integer a2 = 128;  //自动装箱
        Integer b2 = 128;  //自动装箱

        System.out.println(s1 == t1);   //false，两个不同的实例对象
        System.out.println(s1.equals(t1));   //true

        System.out.println(s2 == t2);       //false，两个不同的实例对象
        System.out.println(s2.equals(t2));   //true

        System.out.println(a1 == b1);     //true，支持自动装箱且值位于-128到127之间，都指向IntegerCache缓存中的同一个Integer对象
        System.out.println(a1.equals(b1));   //true

        System.out.println(a2 == b2);     //false，支持自动装箱但值不在-128到127之间支持自动装箱，不能引用IntegerCache缓存中的同一个Integer对象，需要额外创建两个Integer对象
        System.out.println(a2.equals(b2));   //true

    }
}


编辑于 2020-02-11 14:03:16 回复(2)
惠鸿飞头像 惠鸿飞
记住：
“==”是判断两个是否为同一对象的引用；
“.equals”是判断两个的值是否相等
s和t都是Integer的对象，但是引用不同，s/t和u类型都不一样。
发表于 2019-09-17 17:20:00 回复(0)
🐷头201903041448838头像 🐷头201903041448838

A.因为s是Integer类型，u是Long类型，不同类型不能用“==”比较，为false

B.s，t因为new了Integer，所以他们指向不同对象的堆，“==”比较地址（非基本类型），为false

C、D、E. Integer重写了equals方法，比较的是值，为true

发表于 2019-09-06 11:01:14 回复(0)
思而行者头像 思而行者
注意Integer中数值在【-128到127】是为同一个对象的情况是下面这种使用valueOf方法的情况
Integer i1 = 100; Integer i2 = 100;
 System.out.println(i1 == i2); //输出true
即Integer i = Integer.valueOf(100)

而Integer i1 = new Integer(1);
Integer i2 = new Integer(1);
这里则是分别在堆中创建了两个不同的对象；

参考高赞第一进行总结回顾
发表于 2023-05-09 11:58:42 回复(0)
_Harper头像 _Harper
1. 在 -128~127时，不用new时用==判断是相等的
2. int和integer比较是相等的，其他的不行
3. equal比较只需值相等
发表于 2022-03-27 16:54:42 回复(0)
这个昵称没想好头像 这个昵称没想好
A      Operator '==' cannot be applied to 'java.lang.Integer', 'java.lang.Long'

发表于 2019-09-23 10:24:33 回复(0)
提交观点

问题信息

Java 迅雷
上传者：温柔的牛奶
难度：
79条回答 16101浏览

热门推荐

相关试题

扫一扫，把题目装进口袋

求职之前，先上牛客

扫描二维码，进入QQ群

扫描二维码，关注牛客公众号