首页 > 试题广场 >

下列 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
  • 对于不同的环境结果不同
  • 程序无法执行
查看正确选项
添加回答
mcq头像 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 回复(56)
furnace09头像 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头像 StrongYoung

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

 

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

发表于 2015-10-08 16:01:23 回复(12)
LanCho头像 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 回复(13)
全三三头像 全三三
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头像 小牛快跑233
这道题不严谨，JDK1.5版本之后才支持自动装箱和自动拆箱。
也就是说，JDK1.5以后的运行环境是输出true,true。
而JDK1.5之前，编译会报错。
应该选择E。（一般大公司出的面试题都是指定运行版本的）
发表于 2016-08-05 01:15:42 回复(2)
ItLhb头像 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头像 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头像 Top0NE
int类型与Integer进行比较，Integer会自动拆箱成Int类型
发表于 2015-09-18 13:15:15 回复(1)
左手201809131222262头像 左手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头像 i4maxin
Integer的equals被重载了，和String的一样，会取出值比较
发表于 2022-02-27 18:52:01 回复(0)
牛客315366号头像 牛客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头像 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头像 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号头像 牛客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)
宋佑廉头像 宋佑廉

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

j.equals(i) ，调用 equals 方法后，这个 i 会自动装箱成 Integer 类型，然后再比较值，所以也返回真
大家注意和String类型分开,因为String不是基本的数据类型,所以不存在拆箱装箱的操作.
发表于 2018-10-27 23:37:27 回复(0)
提交观点

问题信息

Java
来自：阿里巴巴2016研发工...
难度：
123条回答 24406浏览

热门推荐

相关试题

扫一扫，把题目装进口袋

求职之前，先上牛客

扫描二维码，进入QQ群

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