首页 > 试题广场 >

在jdk1.5的环境下，有如下4条语句，以下输出结果为fal

[单选题]

在jdk1.5的环境下，有如下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);
```

查看答案及解析

推荐

牛客-007

答案：C

JVM中一个字节以下的整型数据会在JVM启动的时候加载进内存，除非用new Integer()显式的创建对象，否则都是同一个对象

所有只有i04是一个新对象，其他都是同一个对象。所有A，B选项为true

C选项i03和i04是两个不同的对象，返回false

D选项i02是基本数据类型，比较的时候比较的是数值，返回true

编辑于 2015-01-19 21:48:59 回复(28)

StrongYoung

Integer i01=59 的时候，会调用 Integer 的 valueOf 方法，

   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); }

这个方法就是返回一个 Integer 对象，只是在返回之前，看作了一个判断，判断当前 i 的值是否在 [-128,127] 区别，且 IntegerCache 中是否存在此对象，如果存在，则直接返回引用，否则，创建一个新的对象。

在这里的话，因为程序初次运行，没有 59 ，所以，直接创建了一个新的对象。

int i02=59 ，这是一个基本类型，存储在栈中。

Integer i03 =Integer.valueOf(59); 因为 IntegerCache 中已经存在此对象，所以，直接返回引用。

Integer i04 = new Integer(59) ；直接创建一个新的对象。

System. out .println(i01== i02); i01 是 Integer 对象， i02 是 int ，这里比较的不是地址，而是值。 Integer 会自动拆箱成 int ，然后进行值的比较。所以，为真。

System. out .println(i01== i03); 因为 i03 返回的是 i01 的引用，所以，为真。

System. out .println(i03==i04); 因为 i04 是重新创建的对象，所以 i03,i04 是指向不同的对象，因此比较结果为假。

System. out .println(i02== i04); 因为 i02 是基本类型，所以此时 i04 会自动拆箱，进行值比较，所以，结果为真。

编辑于 2015-10-08 15:07:10 回复(58)

ixiaomo

1、看一下源码大家都会明白，对于-128到127之间的数，会进行缓存，Integer i01 = 59时，会将59进行缓存，下次再写Integer i02 = 59时，就会直接从缓存中取，就不会new了。除非new Integer(59)，就不是缓存中原来的那个59了。

2、int和integer(无论new否)比，都为true，因为会把Integer自动拆箱为int再去比。

发表于 2016-04-16 10:16:32 回复(1)

haoa

i04 用new创建了一个新对象，对象与对象之前用==比较肯定是false啦

其他三个都是同一个对象。

Integer与int进行==比较时，Integer会自动拆包成int型

发表于 2015-10-13 10:09:15 回复(1)

粉红粉红的Hat

基于java的包装类来说，对于某些频繁使用的值，系统提供了包装类的缓存（和String常量拥有字符串常量池一样），当需要时直接从缓冲中提取，而不是在创建一个新的包装类对象，缓存的包装类的值如下：

boolean：true和false

byte：-128~127

char：0~127

short、int、long：-128~127

所以上面的i01 i02 i03 是同一个对象，存储在常量池中，而i04是new的对象，存储在栈中；

B选项是比较的相同的地址，故结果为true

A、D选项是基本数据类型与包装类进行“==”比较时，将包装类拆箱为基本数据类型，然后对值进行比较，故结果为true

C选项比较地址，i03在常量池中，而i04在栈中，故两者地址不等；

发表于 2016-08-13 19:01:32 回复(4)

Vicky

跟i02比较会自动拆箱进行值比较，所以所有跟i02比较的都是true. jvm会缓存-128～127之间的整数，在Integer的valueOf()方法中可以看到明显的代码解释，同时int自动装箱是使用Integer的valueOf()方法封装成Integer的，所以i01==i03. 至于i04，由于new的存在不会使用Integer的缓存，所以i03！=i04

编辑于 2015-09-11 08:58:46 回复(0)

山巅霞

1，Integer i01 = 59;int i02 = 59;

Integer 和int比较时，自动拆箱，调用的是equals方法，因此比较的是值，故为true。

2，Integer i01 = 59;Integer i03 =Integer.valueOf(59);

Integer i01=59时会自动装箱 Integer.valueOf(59)

所以当i03再次进去的时候发现已经存在59，所以返回i01的引用。

故i01与i03相等。

3,Integer i03 =Integer.valueOf(59)；Integer i04 = new Integer(59)

i03与i04比较的是对象，明显是new 出来的，显然不相等。

4，int i02 = 59;Integer i04 = new Integer(59)

i02与i04同1，比较时会自动拆箱，比较的是值。故是相等的。

综上述，选C

编辑于 2017-09-04 15:08:52 回复(0)

RiseKyle

public class AutoBoxingTest {
    public static void main(String[] args) {
        Integer i01 = 59;
        int i02 = 59;
        Integer i03 = Integer.valueOf(59);
        Integer i04 = new Integer(59);

        Integer i05 = 1000;
        Integer i06 = Integer.valueOf(1000);
        System.out.println(i01 == i02);//自动拆箱成int，进行值比较，所以相等
        System.out.println(i01 == i03);//在Java中，会对-128到127的Integer对象进行缓存，当创建新的Integer对象时，
                                       //如果符合这个这个范围，并且已有存在的相同值的对象，则返回这个对象，否则创建新的Integer对象。
        System.out.println(i03 == i04);//i04显式的创建了一个新的对象，所以与i03是不同的对象
        System.out.println(i02 == i04);//自动拆箱，进行值比较，相等
        System.out.println(i05 == i06);//由于1000超出缓存对象范围，i06为新创建的对象引用，所以不相同

    }
}

关于Java自动拆装箱机制请访问我的博客http://risekyle.me/2017/07/05/Java%E8%87%AA%E5%8A%A8%E6%8B%86%E8%A3%85%E7%AE%B1%E6%9C%BA%E5%88%B6/

编辑于 2017-07-11 19:46:40 回复(0)

Coding.Si

Integer i1 = 59;
int i2 = 59;
 
Integer i3 = Integer.valueOf(59);
Integer i4 = new Integer(59);

System.out.println(i1 == i2);//true 
System.out.println(i1 == i3);//true 
System.out.println(i2 == i3);//true 
System.out.println(i1 == i4);//false 
System.out.println(i2 == i4);//true 
System.out.println(i3 == i4);//false

解析：

1. int不参与，单讲Integer本身：两者都是new出来的不相等；两者都是=出来的相等；一个是new，一个是=出来的，就不相等。

2. int参与。Integer可以自动拆箱（jdk1.5以上）。所以int和Integer比较，不管什么形式的赋值的都相等。

3. Integer.valueOf(值)这种情况。-128<=值<=127之间时，valueOf相当于对值进行缓存，其他代码若有Integer值=127(不同于Integer值=new Integer(127))，就会从缓存中直接取出，不会进行new，所以相等；不在这个范围时，valueOf相当于new Integer(值)。

4. JAVA在编译int i=值（值<-128&&值>127）时，会被翻译成Integer i= Integer.valueOf(值)。所以两者在特定情况下相等。

编辑于 2016-09-24 15:17:50 回复(0)

MIT_HIT

JVM中一个字节以下的整型数据会在JVM启动的时候加载进内存，除非用new Integer()显式的创建对象，否则都是同一个对象

所有只有i04是一个新对象，其他都是同一个对象。所有A，B选项为true

C选项i03和i04是两个不同的对象，返回false

D选项i02是基本数据类型，比较的时候比较的是数值，返回true

发表于 2015-11-10 10:59:47 回复(0)

山石小组

我只想说一句，拿这种东西面试，有意思吗？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？

发表于 2016-10-14 13:45:26 回复(2)

ddscory

只有new integer的对象才与其他不同

发表于 2018-09-28 13:34:59 回复(0)

无知者无畏

强烈推荐看下这篇博文，讲的很详细

https://blog.csdn.net/dawn_after_dark/article/details/74154338

发表于 2018-09-09 19:24:07 回复(0)

牛客-120抢救中心

拆箱

发表于 2018-08-08 15:41:46 回复(2)

.牛妹

C: i03和i04是new了两个对象，对应堆中两个不同的对象，==比较的是他们的地址，所以当然false。

A: i01和i02进行比较，由于一个是基本类型int，Integer会进行自动拆箱成一个int，比较的话就是他们的数值59,所以相等。

B: i01和i03都会进行自动装箱，而Integer对-128~127这些常用的数有一个缓冲，存放了他们对应的Integer对象，因此取出的都是同一对象

D: 同A

发表于 2017-07-08 21:51:11 回复(0)

G^J

Integer类的源码中用了一个数组缓存了-128到127之间的的整形，在自动装箱的时候把这区间内的整形缓存到数组中，下次再用到时直接取出缓存来用(同一块内存)。当是用new构造一个新的Integer类时，缓存就不是同一个了，所以缓存里面对象也不是同一个(同一块内存)了。当int与Integer比较时，是直接取出Integer中的数字来和整形比较(而不是比较内存)

发表于 2017-03-22 09:05:32 回复(0)

雨杉

分2部：
【1】有基本数据类型进行比较，比较的都是数值，所以AD为true
【2】《借鉴牛客-007评论》JVM中**一个字节以下的整型数据**会在JVM启动的时候加载进内存，除非用new Integer()显式的创建对象，否则都是同一个对象 
所有只有i04是一个新对象，其他都是同一个对象。
另外，Integer.valueOf(String s)//返回一个指定字符串值的整数对象

发表于 2017-02-14 13:07:11 回复(0)

追赶大废

Integer i1 = 59;
int i2 = 59;
Integer i3 = Integer.valueOf(59);
Integer i4  = new Integer(59);
System.out.println(i1 == i2);//true
System.out.println(i1 == i4);//false
System.out.println(i2 == i3);//true
System.out.println(i3 == i4);//false
System.out.println(i2 == i4);//true

编辑于 2016-03-14 13:47:35 回复(1)

大河儿马

Integer与int进行==比较时，Integer会自动拆包成int型

发表于 2015-09-14 10:10:33 回复(0)

linko解万

答案：C

思路：i02为基本数据类型，有基本数据类型的都是比较值，所以A、D为TRUE。i01和i03在-128--127之间分配机制是一样的，所以i01==i03。i03和i04分配内存的机制是不一样的，所以为false。

发表于 2014-12-31 02:23:26 回复(2)

bbblemon

选C

说一下基本数据类型和包装类的比较。

1. 只要涉及到基本数据类型，一直表示的是值比较。也就是说，只要==号左边或者右边有一个是基本数据类型，那么就是值比较。

2. 如果==号左右两边都是包装类，那么==号表示引用类型所指地址是否一致。

注意：

1. 因为Integer这个包装类比较特殊，内部有一个数组***数组，保存了-128到127的值，也就是Integer i = n，只要n在-128到127之间，都是直接从***数组中获取，不会再创建新的对象。

2. 对于其他的包装类，比如Double d = 2.1；那么2.1会被自动装箱，也就是调用valueOf方法，这个方法内部还是new了一个Double对象的。

3. 同时需要注意，自动装箱可不提供向上转型，也就是Double d = 1；1不会先自动向上转成double然后再装箱，会直接编译错误，因为Double这个包装类中就没有形参是int的构造器，其他包装类也是一样的。

3. 包装类的equals方法，不提供类型转换。例如Byte b = 100；Integer i = 100；i.equals(b);返回false。

1. equals方法先比较类型，再比较值。

发表于 2018-07-12 11:07:00 回复(2)

提交观点

问题信息

Java 人人网

来自：Java工程师能力评估

上传者：小小

难度：

92条回答 9882收藏 23125浏览

在jdk1.5的环境下，有如下4条语句，以下输出结果为fal

问题信息

热门推荐

相关试题