首页 > 试题广场 >

下列 java 程序输出结果为______。

[单选题]

在jdk1.5之后，下列 java 程序输出结果为______。

int i=0;
Integer j = new Integer(0);
System.out.println(i==j);
System.out.println(j.equals(i));

```
true,false
```
```
true,true
```
```
false,true
```
```
false,false
```
```
对于不同的环境结果不同
```
```
程序无法执行
```

查看正确选项

李修行

第一个true, 自动装箱和整形常量池，i==j时，i装箱成integer,无论原本是integer i=new integer,还是int i,当整形数在-128到127时，地址都从整形常量池中获取，也就是地址相同，第二个true,equals比较值，拆箱成int,

发表于 2018-03-08 09:17:35 回复(0)

更多回答

mcq

本题是一个自动拆装箱的考题(自动拆装箱JDK需在1.5上），下面的讨论都不针对新开辟对象的情况：
1、基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；
2、两个Integer类型进行“==”比较，如果其值在-128至127，那么返回true，否则返回false, 这跟Integer.valueOf()的缓冲对象有关，这里不进行赘述。
3、两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true
4、基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型，再进行3中的比较。

int a=257;
Integer b=257;
Integer c=257;
Integer b2=57;
Integer c2=57;
System.out.println(a==b);
//System.out.println(a.equals(b)); 编译出错，基本型不能调用equals()
System.out.println(b.equals(257.0));
System.out.println(b==c);
System.out.println(b2==c2);

因此上面的代码的结果因此为 true, false, false, true

编辑于 2018-08-24 17:42:59 回复(52)

云谷子

这个有点不懂，equals方法1.6中写的：比较此对象与指定对象。当且仅当参数不为null，并且是一个与该对象包含相同int值的Integer对象时，结果为true。为啥题中i不是Integer对象还能返回true呢？哪位大神知道帮忙回答下吧非常感谢

发表于 2016-02-25 09:37:59 回复(2)

furnace09

==如果是primitive主类型，那么比较值；如果是对象，那么比较引用地址

equals需要根据具体对象的实现来判断，在Integer里面是判断值是否相等

一般说来，如果是两个Integer类型进行==比较，就是比较两个Integer对象的地址。但是有一点需要注意的是在-128至127这个区间，如果创建Integer对象的时候（1）Integer i = 1; （2） Integer i = Integer.valueOf(1); 如果是这两种情况创建出来的对象，那么其实只会创建一个对象，这些对象已经缓存在一个叫做IntegerCache里面了，所以==比较是相等的。

如果不在-128至127这个区间，不管是通过什么方式创建出来的对象，==永远是false，也就是说他们的地址永远不会相等。

编辑于 2015-09-04 02:07:31 回复(14)

StrongYoung

i==j ，这个是基本类型与 Integer 的比较， j 会自动拆箱成 int 类型，然后比较的是值。因此返回真。

j.equals(i) ，调用 equals 方法后，这个 i 会自动装箱成 Integer 类型，然后再比较值，所以也返回真。

发表于 2015-10-08 16:01:23 回复(12)

LanCho

总体主要分为两个方面
①比较的是值
一、基本数据类型与引用数据类型进行比较时，引用数据类型会进行拆箱，然后与基本数据类型进行值的比较
举例：
int i = 12;
Integer j = new Integer(12);
i == j 返回的是true
二、引用数据类型与基本数据类型进行比较（equals方法），基本数据类型会进行自动装箱，与引用数据类型进行比较，Object中的equals方法比较的是地址，但是Integer类已经重写了equals方法，只要两个对象的值相同，则可视为同一对象，具体看API文档，所以这归根到底也是值的比较！
举例：
int i = 12;
Integer j = new Integer(12);
j.equals(i) 返回的是true
②比较的是地址
一、如果引用数据类型是这样 Integer i = 12;直接从常量池取对象，这是如果数值是在-128与127之间，则视为同一对象，否则视为不同对象
举例：
Integer i = 12; Integer j = 12; i == j 返回的是true
Integer i = 128; Integer j = 128; i == j 返回的是false
二、如果引用数据类型是直接new的话，不管值是否相同，这时两个对象都是不相同的，因为都会各自在堆内存中开辟一块空间
举例：
Integer i =new Integer(12);
Integer j = new Integer(12);
i == j 这时返回的是false
三、从常量池取对象跟new出来的对象也是不同的
举例：
Integer i = 12;
Integer j = new Integer(12)
i == j 这时返回的是false，因为第二个语句其实已经是new了两个对象了！！！

发表于 2016-09-20 21:09:04 回复(12)

全三三

int类型与Integer进行比较，Integer会自动拆箱成Int类型再比较，所以为true。

发表于 2015-08-26 13:59:41 回复(4)

厚德载物

解析：

引用类型 Interger j 与数值类型 int I 进行比较时比较的是 value ，而不是地址因此 i==j 返回 true ，而 j.equals(i) 同样比较的是 value ，因此返回的是 true

发表于 2015-08-24 23:42:01 回复(4)

小牛快跑233

这道题不严谨，JDK1.5版本之后才支持自动装箱和自动拆箱。

也就是说，JDK1.5以后的运行环境是输出true,true。

而JDK1.5之前，编译会报错。

应该选择E。（一般大公司出的面试题都是指定运行版本的）

发表于 2016-08-05 01:15:42 回复(2)

ItLhb

①无论如何，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再去比

发表于 2016-05-09 09:04:30 回复(0)

zhangshuiqing

Integer m = new Integer(1);

Integer n = new Integer(1);

都是new出来的对象，在堆中，而且不存在拆箱和享元模式的问题，因此是不等

Integer m = 1;

Integer n = new Integer(1);

m在常量池中，而n在堆里，两个都是Integer类型，因此不等

Integer m = 1;

Integer n = 1;

不是new出来的，而且数值在-128~127之间，因此相等

Integer m = 128;

int n = 128;

Integer k = new Integer(128);

两边类型不一样，自动拆箱，比较数值，因此 m==n true； m==k false; n==k true

发表于 2016-04-06 10:23:33 回复(2)

Top0NE

int类型与Integer进行比较，Integer会自动拆箱成Int类型

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

左手201809131222262

一。首先说结论：

（1）int与Integer、new Integer()比较时，结果永远为true

（2）Integer与new Integer()比较时，结果永远为false

（3）Integer与Integer比较时，看范围；在大于等于-128小于等于127的范围内为true，在此范围外为false。

下面是解析过程：

1.Integer与int比较时，Integer会有拆箱的过程，我们可以看看拆箱的代码：

直接返回的就是value，因此int与Integer以及new Integer()进行 ==比较时结果都是true。

2.Integer a=n时，如果n大于等于-128小于等于127时，会直接从IntegerCache中取，不在这个范围内，会new一个对象，所以Integer与new Integer进行 ==比较时，结果都是false。

3.Integer与Integer比较，需要看范围，如果在-128~127(包含-128，不包含127)范围内，因为都是从IntegerCache中取值，所以相等；若不在这个范围内，则都要去new一个对象，所以结果为false。

附上计算结果：

二。

Integer是包装类型，比较使用equals()，Integer覆写了equals()方法，equals比较先看类型，若类型相同再看值；

public boolean equals(Object obj) {

 if (obj instanceof Integer) {

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

 return false;

编辑于 2019-12-31 14:44:17 回复(1)

i4maxin

Integer的equals被重载了，和String的一样，会取出值比较

发表于 2022-02-27 18:52:01 回复(0)

牛客315366号

一般==用于比较基本类型的数值，equals()用于引用类型，==比较的是两者的值，equals（）在没有被覆盖时，比较的是两者的内存地址是否相同，但一般String，Date，Integer的equal（）都被覆盖了，所以比较的是两者的value，比如：A a=new A（“abc”） ,b="abc",a.equals(b)为TRUE，

发表于 2016-08-24 15:39:46 回复(0)

freeland

Java使用自动装箱和拆箱机制，节省了常用数值的内存开销和创建对象的开销，提高了效率。通过上面的研究和测试，结论如下：

（1）Integer和 int之间可以进行各种比较；Integer对象将自动拆箱后与int值比较

（2）两个Integer对象之间也可以用>、<等符号比较大小；两个Integer对象都拆箱后，再比较大小

（3）两个Integer对象最好不要用==比较。因为：-128~127范围(一般是这个范围)内是取缓存内对象用，所以相等，该范围外是两个不同对象引用比较，所以不等。

public static Integer valueOf(int i) {
    if(i >= -128 && i <= IntegerCache.high)　// 没有设置的话，IngegerCache.high 默认是127
        return IntegerCache.***[i + 128];
    else
        return new Integer(i);
}

发表于 2016-03-22 08:32:02 回复(0)

Razertory

java中定义的常量包括字符串常量会首先放到常量池里面，当有新的对象产生时候，会与常量池的内容比较，如果值相同，那么就会共享一样的引用。

发表于 2015-10-21 10:30:47 回复(0)

达军行

java Integer和int之间==的比较问题。如下实例 public static void main(String[] args) { // TODO Auto-generated method stub Integer a = new Integer(1); Integer b = new Integer(1); int c=1; Integer e = 1; System.out.println("a==b:"+(a==b)); System.out.println("a==c:"+(a==c)); System.out.println("a==e:"+(a==e)); System.out.println("c==e:"+(c==e)); } 结果： a==b:false a==c:true a==e:false c==e:true 回答： Integer是int的封装对象，两个对象==比较的是栈的值 Integer a = new Integer(1); Integer b = new Integer(1); a与b存的是Integer的堆中的地址，而不是值 a、b指向堆中的地址显然不同所以 a==b 为false int c = 1; int为值类型，引用类型Integer与值类型int比较显然比较的是值因为int在堆中是不开辟内存的，他在栈中的值则为他本身的值所以a==c比较的是他们各自的value， a==c为true Integer e=1; 这个比较特殊，直接赋值它有独立的内存，每次赋值时将检查内存中是否有值跟他匹配的，若有则把此内存地址付给e，若没有，开辟新的内存你可以尝试下面的例子： Integer t = 1; Integer t1 = 1; t==t1 为true，如上所说，此时t与t1指向的是同一块内存 new 一定是开辟新的内存，直接赋值则不一定开辟新的内存因为a的引用指向堆，而e指向专门存放他的内存，所以他们的内存地址不一样所以a==e为false c==e等同于 a==c，一个引用类型一个值类型不一定是飞机

发表于 2015-10-05 18:26:28 回复(0)

牛客337939981号

基本数据类型与引用数据类型进行比较时，引用数据类型会进行拆箱，然后与基本数据类型进行值的比较

发表于 2022-06-05 15:05:49 回复(0)

程序员浓眉

int和Integer==比较的时候会发生自动拆装箱，Integer会自动调用intValue拆箱，所以比较的是值。如果两个Integer比较在127-（-128）之间会有缓存拿到的是同一个，所以==为true。但两个Integer都是new出来的，那么==为false，这一点和String很像

发表于 2022-02-08 00:41:32 回复(0)

仲秋二十五

记录一下大佬的题解 ①比较的是值一、基本数据类型与引用数据类型进行比较时，引用数据类型会进行拆箱，然后与基本数据类型进行值的比较举例： int i = 12; Integer j = new Integer(12); i == j 返回的是true 二、引用数据类型与基本数据类型进行比较（equals方法），基本数据类型会进行自动装箱，与引用数据类型进行比较，Object中的equals方法比较的是地址，但是Integer类已经重写了equals方法，只要两个对象的值相同，则可视为同一对象，具体看API文档，所以这归根到底也是值的比较！举例： int i = 12; Integer j = new Integer(12); j.equals(i) 返回的是true ②比较的是地址一、如果引用数据类型是这样 Integer i = 12;直接从常量池取对象，这是如果数值是在-128与127之间，则视为同一对象，否则视为不同对象举例： Integer i = 12; Integer j = 12; i == j 返回的是true Integer i = 128; Integer j = 128; i == j 返回的是false 二、如果引用数据类型是直接new的话，不管值是否相同，这时两个对象都是不相同的，因为都会各自在堆内存中开辟一块空间举例： Integer i =new Integer(12); Integer j = new Integer(12); i == j 这时返回的是false 三、从常量池取对象跟new出来的对象也是不同的举例： Integer i = 12; Integer j = new Integer(12) i == j 这时返回的是false，因为第二个语句其实已经是new了两个对象了！！！

发表于 2021-10-29 11:01:18 回复(0)

提交观点

问题信息

Java

来自：阿里巴巴2016研发工...

难度：

122条回答 10500收藏 24047浏览

下列 java 程序输出结果为______。

问题信息

热门推荐

相关试题