首页 > 试题广场 >

以下输出结果为false的是

[单选题]
有如下4条语句：() 
Integer i01=59;
int i02=59;
Integer i03=Integer.valueOf(59);
Integer i04=new Integer(59);
以下输出结果为false的是: 
  • System.out.println(i01==i02);
  • System.out.println(i01==i03);
  • System.out.println(i03==i04);
  • System.out.println(i02==i04);
查看答案及解析
添加回答
推荐
笔墨桑头像 笔墨桑
C

这道题我是选错了的，看了楼上victor123的答案觉得又学到新知识了，于是乎就搜了一下，写点自己的理解。
首先常量池这个概念，原来以为只要是一个整型，都会放进到常量池，比如，0,1,12222222等。查找后发现，Byte,Short,Integer,Long,Character这5种整型的包装类也只是在对应值小于等于127并且大于等于-128时才可使用常量池，因为他们至占用一个字节(-128~127);

再者Integer.valueOf方法中也有判断，如果传递的整型变量>= -128并且小于127时会返回IntegerCache类中一个静态数组中的某一个对象， 否则会返回一个新的Integer对象,代码如下 
public static Integer valueOf(int i) {
        assert IntegerCache.high >= 127;
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.***[i + (-IntegerCache.low)];
        return new Integer(i);
    }
所以如果你测试如下代码 
public static void main(String[] args) {
		
		Integer a = 127;
		Integer b = 127;
		
		Integer c = 128;
		Integer d = 128;
		
		System.out.println(a == b);
		System.out.println(c == d);
	}
结合自动封装、常量池以及Integer.valueOf方法就不难得出，答案时true和false；
再看本题 
	Integer i01=59;
	int i02=59;
	Integer i03=Integer.valueOf(59);
	Integer i04=new Integer(59);
第一行：由于59在-128~127范围之内，所以在自动装箱的时候，会返回IntegerCache[59 - (-128)];
第三行：同第一行
第四行：因为有new关键字，所以在heap中开辟了一块新内存放置值为59的Integer对象。 
System.out.println(i01==i02);//正确
System.out.println(i01==i03);//正确，都指向IntegerCache[59-(-128)]对象
System.out.println(i03==i04);//错误，引用指向的对象地址不同
System.out.println(i02==i04);//正确



编辑于 2015-12-07 17:45:36 回复(36)
请叫我猿叔叔头像 请叫我猿叔叔
发表于 2016-07-17 21:20:44 回复(53)
秦王头像 秦王
①无论如何，Integer与new Integer不会相等。不会经历拆箱过程，
  ②两个都是非new出来的Integer，如果数在-128到127之间，则是true,否则为false
  java在编译Integer i2 = 128的时候,被翻译成-> Integer i2 = Integer.valueOf(128);而valueOf()函数会对-128到127之间的数进行缓存
  ③两个都是new出来的,都为false
  ④int和integer(无论new否)比，都为true，因为会把Integer自动拆箱为int再去比
发表于 2015-11-29 15:36:32 回复(28)
HoagsGalaxy头像 HoagsGalaxy
i01 == i03 如果不看编译器警告，执行返回的结果也是 true。Integer i01=59; 执行时用 javap 可以看出就是 Integer i03=Integer.valueOf(59); 而 Integer 在调用 valueOf() 时会判断取值范围从而给出缓存值地址或者创建新的对象的地址。
发表于 2022-02-28 18:11:54 回复(0)
牛客54197100号头像 牛客54197100号
自动拆箱
发表于 2021-11-27 22:02:39 回复(0)
mohd2021头像 mohd2021
i04用到了new关键字，又开辟了一个内存块，这时候i03和i04所指向的内存块是不一样的，即地址不一样，故用==得出FALSE结果
发表于 2021-08-31 09:20:54 回复(0)
牛客255019343号头像 牛客255019343号
“==”两边比较基本类型时，比较的是值，若“==”两边比较的是对象，比较的是对象引用地址
编辑于 2021-07-09 00:14:47 回复(0)
牛客957123464号头像 牛客957123464号
<p>拆箱装箱</p><p><br></p>
发表于 2020-08-05 23:23:26 回复(0)
zzd007头像 zzd007
== 对象比较的是地址，基本数据类型比较的是值。Integer i=59;int j =59;Integer k=Integer.valueOf(59); i==j比较的是值（将包装类型i拆箱，再与j比较）；i==k比较的是地址，在-127到128之间，i是从常量池中取值；在-127到128之间，Integer的valueOf方法也是从常量池中取值，这时i==k;当超过这个范围的时候，会在内存中new一个对象给k，这时i==k为false。String、Byte等包装类也有常量池。Integer m=newInteger(59)，如果是new的对象，无论大小是否在-127到128之间，都不是从常量池中取值，所以m与i、k地址都不一样。
发表于 2019-10-23 17:36:36 回复(0)
pixelpig头像 pixelpig
int 和 Integer比较，由于int是基本类型，Integer 会自动拆箱变为int 所以一致。
发表于 2017-07-03 13:50:42 回复(0)
jayson头像 jayson
http://blog.csdn.net/wangwangfish/article/details/8055044
发表于 2015-12-07 17:18:47 回复(0)
亚当斯密头像 亚当斯密
package 牛客网;

public class a_1 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
            Integer i01=59;
            int i02=59;
            Integer i03=Integer.valueOf(59);
            int i04=new Integer(59);
            System.out.println(i01==i02);
            System.out.println(i01==i03);
            System.out.println(i03==i04);
            System.out.println(i02==i04);
    }

}
编译执行了一下，为啥都是true？
发表于 2015-11-13 16:54:21 回复(2)
月舞云袖头像 月舞云袖

Integer i01=59;//自动装箱，实质就是调用Integer.valueOf(int i)方法，如果-128<i<127，则直接返回常量池中的值，否则new一个。 在该题中，i01 == i02 == i03 都是返回常量池中的值。 int和Integer 比较时，Integer会先进行拆装，比较的是两个的值是否相等。

编辑于 2017-02-21 09:59:44 回复(0)
zhangqiangeek头像 zhangqiangeek
原文博客地址：http://cs-css.iteye.com/blog/1815296

一。 Integer 类型对象之间大小比较

1.  使用 new Integer() 创建的对象 :

首先，我们知道，在java中，基本类型之间是可以做大小比较的，例如int i=1,int j=2，是可以直接使用关系运算符“<”、“>”、“==”等符号来做比较的。但在实际开发中，基本类型的包装类更为常用，那么包装类型的比较运算是如何呢？

在main方法中执行下面代码：

Java代码  收藏代码
  1. Integer i = new Integer(100);  
  2. Integer j = new Integer(100);  
  3. System.out.println(i==j);  

 

有人可能会说，jdk1.5以后，基本类型和包装类型之间是可以自由转换的，那么Integer对象也可以直接用关系运算符来做比较，但实际情况并非这样。执行上述代码，打印结果是：

false

其实原因很简单，上述代码中我们执行了两次new，所以创建了两个Integer型的对象，对象之间的“==”符是用来比较是否是一个对象的两个引用（即比较地址是否相同），上述代码中，两次new出来的对象地址显然是不可能相同的，故打印结果是false。

那么对于“<”、“>”这样的运算符呢？执行下面代码：

Java代码  收藏代码
  1. Integer i = new Integer(100);  
  2. Integer j = new Integer(300);  
  3. System.out.println(i<j);  

 

打印结果是true，经过实验，对于“<=”、“>=”符号也是一样的

结论1：使用new关键字创建的包装类型对象，不可以直接使用“==”来做大小比较，但可以使用“<”、“>”、“<=”、“>=”来做大小比较。

2.   使用 Integer.valueOf() 创建的对象

当然，创建包装类型对象不一定非要使用new关键字，以Integer为例，我们可以使用Integer.valueOf()方法创建Integer对象。那么这种方法创建的对象如何做大小比较呢？执行下面的代码：

Java代码  收藏代码
  1. Integer i = Integer.valueOf(100);  
  2. Integer j = Integer.valueOf(100);  
  3. System.out.println(i==j);  

 

执行后，我们发现，打印结果是true。

根据这个结果，我们是否可以认为，通过valueOf方法创建的对象，可以直接使用关系运算符做比较呢？

先别急，再执行一段代码：

Java代码  收藏代码
  1. Integer i = Integer.valueOf(400);  
  2. Integer j = Integer.valueOf(400);  
  3. System.out.println(i==j);  

 

这段代码，打印结果居然是false！

那么对于“<”、“>”、“<=”、“>=”这几个符号呢？通过实验，得出的结论和1中相同，这几个符号仍然可以直接使用。

看来我们又可以得出一个结论，

结论2：通过valueOf方法创建的Integer对象，也不能随便使用“==”比较大小，但可以使用“<”、“>”、“<=”、“>=”来做大小比较。

3. 使用基本类型赋值创建的对象

相比前两种方法，我们平时更常用的是直接将基本类型对象赋值给包装类型（即自动装箱），比如Integer i = 100这样的语法。那么通过这种方法创建的对象，可否使用关系运算符来比较大小呢？

Java代码  收藏代码
  1. Integer i = 100;  
  2. Integer j = 100;  
  3. System.out.println(i==j);  

 

执行上面的代码，发现打印结果是true。当然有了2中的经验，我们使用400这个数来再试一次：

Java代码  收藏代码
  1. Integer i = 400;  
  2. Integer j = 400;  
  3. System.out.println(i==j);  

 

执行这段代码后，发现和2中情况一样，仍然打印false；

通过实验，对于“<”、“>”、“<=”、“>=”这几个符号，和上面的情况都是一样的。

结论3：使用Integer i = 400这种方法创建的包装类对象，也不能随便使用“==”来比较大小，但可以使用“<”、“>”、“<=”、“>=”来做大小比较。

这些现象是什么原因导致的呢？请看下面的分析。

二。Integer 对象不同创建方法之间的区别

上文得出的三个小结论，都说明了一个问题，包装类型是不能够随便使用关系运算符比较大小的，针对三种创建对象的方法，原因分析如下：

首先，对于new关键字创建的包装类对象，原因在上文已经说过了，两次new得到的对象引用地址是不同的，不能使用“==”关键字做大小比较。而使用“<”和“>”等运算符时，包装类型会调用valueOf方法，将运算符两边的对象都转换为基本类型后再做比较。这就是为何“==”不能使用而“<”、“>”、“<=”、“>=”这几个符号可以使用的原因。

第二，使用valueOf方法创建的Integer对象，使用“==”符号时，运行结果有时候正确，有时候不正确。查看valueOf方法的源码，如下：

Java代码  收藏代码
  1. public static Integer valueOf(int i) {    
  2.        if(i >= -128 && i <= IntegerCache.high)    
  3.            return IntegerCache.***[i + 128];    
  4.        else    
  5.            return new Integer(i);    
  6. }    

 

通过看源码能够知道，整数类型在-128～127之间时，会使用缓存，造成的效果就是，如果已经创建了一个相同的整数，使用valueOf创建第二次时，不会使用new关键字，而用已经缓存的对象。所以使用valueOf方法创建两次对象，若对应的数值相同，且数值在-128～127之间时，两个对象都指向同一个地址。

最后，使用Integer i = 400这样的方式来创建Integer对象，与valueOf方法的效果是一样的，不再赘述。

总之，包装类对象不可使用“==”符做比较运算，如果要进行比较运算时，最好使用java类库中的compareTo方法

发表于 2016-07-15 09:15:15 回复(6)
victor123头像 victor123
Integer i01 = 59. 直接赋值数字，java会自动装箱，自动调用Integer.valueOf(59). 
Integer i03 = Integer.valueOf(59).  Integer.valueOf(int i)会返回一个Integer对象，当i在-128~127之间时，会返回缓存中已创建的Integer对象。
Integer i04 = new Integer(59) 返回一个新的对象。
所以这道题中，59在-128~127之间，所以前三条语句返回的是同一个对象（在缓存区已创建的对象），而i04使用new新创建了一个新的对象，所以i04与前面三个对象都不一样。 
发表于 2015-11-04 14:19:02 回复(6)
咸鱼吧，后浪！头像 咸鱼吧，后浪！

copy下高赞回答做个笔记，仅记录：

①无论如何，Integer与new Integer不会相等。不会经历拆箱过程，
②两个都是非new出来的Integer，如果数在-128到127之间，则是true,否则为false
java在编译Integer i2 = 128的时候,被翻译成-> Integer i2 = Integer.valueOf(128);而valueOf()函数会对-128到127之间的数进行缓存
③两个都是new出来的,都为false
④int和integer(无论new否)比，都为true，因为会把Integer自动拆箱为int再去比

图片说明

发表于 2017-09-11 10:34:40 回复(2)
luck头像 luck
ABC答案常量池和对象对比那些就不说了，其他答题者的解答都说得很好，对于D答案，
i02是常量，从常量池里取的没错，i04是对象，指向常量池中的内存也没错，之所以“==”对比结果会为真是因为在进行“==”时会将i04自动拆箱（auto-unboxing）成int，所以对比两个常量比的是值，肯定是true。
编辑于 2015-11-14 00:45:06 回复(5)
毕设毕设毕设毕设头像 毕设毕设毕设毕设
值类型“==”比较的是具体的值，引用类型“==”比较的是地址。
1.int与Integer在进行比较的时候，Integer会自动进行拆箱，转换为int与int进行比较，比较的是具体的值。
2.Integer与Integer比较的时候，由于直接赋值的时候会进行自动装箱（ Integer a = 1 或 Integer a = Integer.valueOf(1) ）,这里需要注意两个问题：
①当整数范围在-128到127之间时，不需要创建新的Integer对象，而是从缓存（IntegerCache）中获取已经创建好的Integer对象。
②当大于或小于这个范围的时候，就会直接调用new Integer来创建Integer对象。
所以Integer a = 128 与 Integer b = Integer.valueOf(128) 都创建了新的Integer对象，用“==”比较会返回false
3.Integer a = new Integer(1)和Integer b = 1不同是因为前者会创建对象，存储在堆中，而后者因为在-128到127的范围内，不会创建新的对象，而是从IntegerCache中获取。两者地址不同，用“==”比较自然会返回false。
编辑于 2017-03-19 16:41:56 回复(1)
Jemmy头像 Jemmy
有几个知识点需要掌握
1. Integer是引用类型，int是原生数据类型。
2   . 对Integer对象，JVM会自动缓存-128~127范围内的值，所以所有在这个范围内的值相等的
    Integer对象都会共用一块内存，而不会开辟多个；超出这个范围内的值对应的Integer对象有多
    少个就开辟多少个内存。
3.  类型转换
        1） Integer与int类型的赋值
                a.把Integer类型赋值给int类型。此时，int类型变量的值会自动装箱成Integer类型，然后
         赋给Integer类型的引用，这里底层就是通过调用valueOf()这个方法来实现所谓的装箱的。
                b.把int类型赋值给Integer类型。此时，Integer类型变量的值会自动拆箱成int类型，然后
        赋给int类型的变量，这里底层则是通过调用intValue()方法来实现所谓的拆箱的。
        2） Integer与int类型的比较
                这里就无所谓是谁与谁比较了，Integer == int与int == Integer的效果是一样的，都会把
        Integer类型变量拆箱成int类型，然后进行比较，相等则返回true，否则返回false。同样，拆
        箱调用的还是intValue()方法。

发表于 2016-08-03 15:07:55 回复(0)
loveincode头像 loveincode
i01==i02 true   i02 是int类型(基本类型)，和i01(包装类型)比较，i01会自动拆箱为基本类型 再比较值是否相等
i01==i03 true   都指向IntegerCache[59-(-128)]对象
i03==i04 false  引用指向的对象地址不同
i04==i02 true   i02 是int类型(基本类型)，和i04(包装类型)比较，i04会自动拆箱为基本类型 再比较值是否相等
发表于 2018-05-24 15:45:46 回复(1)
网络小曦头像 网络小曦
i01和i02比的是数值，i01和i03比的是地址（在编译前定义的数值会从常量获取，-128~127之间 ）， 因为i01和i03都是编译之前定义的，所以是常量池中的同一个对象。i02和i04比较的也是数值（自动 拆装箱），i03和i04比较的是地址，因为i04是编译之后又new出来的对象，所以它的地址必然不在常 量池中，所以i03==io4的结果为false
编辑于 2016-09-10 20:45:15 回复(0)
提交观点

问题信息

Java
来自：完美世界2016研发工...
上传者：SunburstRun
难度：
130条回答 25811浏览

热门推荐

相关试题

扫一扫，把题目装进口袋

求职之前，先上牛客

扫描二维码，进入QQ群

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