首页 > 试题广场 >

以下语句返回值为 true 的是()

[不定项选择题]
以下语句返回值为 true 的是()
  • a1==a2
  • d1==d2
  • b1==b2
  • c1==c2
推荐
A,B.
Integer a1 = 17; 语句执行的是valueOf()方法
public static Integer valueOf(int i) { if (i >= IntegerCache.low && i <= IntegerCache.high)  return IntegerCache.***[i + (-IntegerCache.low)];  return new Integer(i); }
对于-128到127之间的数, Integer直接从数组中取, 故a1, a2指向的是同一个对象, A正确. 
其余都是new出来的对象, 显然地址都不相同.
int类型与Integer类型比较时, 先将Integer拆箱, 再比较值, 故B正确.
编辑于 2019-05-27 14:18:35 回复(4)
A、B。考察的是基本类型装箱/拆箱对象引用(内存地址)是否相同。
Integer a1=17实际上执行了Integer.valueOf(17);
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);
}
  • 选项A,a1、a2赋值给Integer类型,自动装箱。对于–128到127(默认是127)之间的值,Integer.valueOf(int i) 返回的是缓存的Integer对象(并不是新建对象),变量所指向的是同一个对象,所以a1==a2返回true
  • 选项BInteger和int比较会进行自动拆箱,比较的是数值大小,所以d1==d2返回true
  • 选项C,由于超出自动装箱的范围,return返回的是新建的对象,所以对象内存地址不同b1==b2返回false。
  • 选项D,普通new创建对象,两个new创建两个地址不同的对像,所以c1==c2返回false

发表于 2019-05-24 22:49:40 回复(16)
答案是 A和B。
首先a1和a2涉及到自动装箱,等于执行了Integer.valueOf(int i),对于小于等于127的数值会从Integer内置的缓存中获取Integer对象,所以a1和a2的地址是一样的。
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.***[i + (-IntegerCache.low)];
        return new Integer(i);
    } 
同理b1和b2的值大于127,不会使用到缓存,会创建2个Integer对象,他们的地址是不同的,所以b1不等于b2。
c1和c2是两个对象的引用,对象地址不等,所以不相等。
d1和d2,d2是基本类型int型,所以在比较时比较的是值的大小。

编辑于 2019-05-24 15:58:36 回复(0)

关于Integer和int的比较 
1、由于Integer变量实际上是对一个Integer对象的引用,所以两个通过new生成的Integer变量永远是不相等的(因为new生成的是两个对象,其内存地址不同)。

Integer i = new Integer(100); Integer j = new Integer(100);
System.out.print(i == j); //false 

2、Integer变量和int变量比较时,只要两个变量的值是向等的,则结果为true(因为包装类Integer和基本数据类型int比较时,java会自动拆包装为int,然后进行比较,实际上就变为两个int变量的比较)

Integer i = new Integer(100); int j = 100;
System.out.print(i == j); //true 

3、非new生成的Integer变量和new Integer()生成的变量比较时,结果为false。(因为 ①当变量值在-128~127之间时,非new生成的Integer变量指向的是java常量池中的对象,而new Integer()生成的变量指向堆中新建的对象,两者在内存中的地址不同;②当变量值不在-128~127之间时,非new生成Integer变量时,java API中最终会按照new Integer(i)进行处理(参考下面第4条),最终两个Interger的地址同样是不相同的)

Integer i = new Integer(100); Integer j = 100;
System.out.print(i == j); //false 

4、对于两个非new生成的Integer对象,进行比较时,如果两个变量的值在区间-128到127之间,则比较结果为true,如果两个变量的值不在此区间,则比较结果为false

Integer i = 100; Integer j = 100;
System.out.print(i == j); //true 
Integer i = 128; Integer j = 128;
System.out.print(i == j); //false 

对于第4条的原因: 
java在编译Integer i = 100 ;时,会翻译成为Integer i = Integer.valueOf(100);,而java API中对Integer类型的valueOf的定义如下:

public static Integer valueOf(int i){ assert IntegerCache.high >= 127; if (i >= IntegerCache.low && i <= IntegerCache.high){ return IntegerCache.cache[i + (-IntegerCache.low)];
    } return new Integer(i);
}

java对于-128到127之间的数,会进行缓存,Integer i = 127时,会将127进行缓存,下次再写Integer j = 127时,就会直接从缓存中取,就不会new了

发表于 2022-03-22 16:09:29 回复(1)
选项A,a1、a2赋值给Integer类型,自动装箱。对于–128到127(默认是127)之间的值,Integer.valueOf(int i) 返回的是缓存的Integer对象(并不是新建对象),变量所指向的是同一个对象,所以a1==a2返回true。 选项B,Integer和int比较会进行自动拆箱,比较的是数值大小,所以d1==d2返回true。 选项C,由于超出自动装箱的范围,return返回的是新建的对象,所以对象内存地址不同,b1==b2返回false。 选项D,普通new创建对象,两个new创建两个地址不同的对像,所以c1==c2返回fals
发表于 2021-11-03 22:47:07 回复(1)
int类型与Integer类型比较时, 先将Integer拆箱, 再比较值, 故B正确
发表于 2022-05-16 21:32:28 回复(0)
B,java语言中有自动拆装箱机制
编辑于 2019-05-24 15:59:47 回复(0)
A装箱时,一定范围的值是缓存好的,并没有建对象,a对,B包装类和基本类型比较,包装类会拆箱,其实他们计较的是值,b对,C超范围的值,装箱时是新建对象,所以c错,D都new对象了,肯定内存地址不一样,d错
发表于 2022-08-02 00:27:23 回复(0)
对于-128到127之间的数,直接执行Integer.valueof()从缓存中取大于127的都是创建的新对象
发表于 2021-11-27 12:40:03 回复(0)
刷个题能碰到这么多java服了,10道题4个java,我点的不是c/c++?
发表于 2020-10-29 08:09:45 回复(1)

-128 ~  127 不管是new还是直接赋值,都是从数组中取出来的,都是指向相同的数,
超过这个范围的数字,都是new出来的,== 比较都是false ,
equal重写了Integer,所以比较new是相等的,
不管是== 或者 equal ,只要Integer 和 int比较,右边的都会自动拆装箱,最后还是值的比较
发表于 2023-02-19 08:51:56 回复(0)
1、自动装箱,-128 — 127,用缓存,超过就不行
2、Integer和int比较就是自动拆箱,直接数值比较
发表于 2021-11-18 16:56:45 回复(0)
Integer和int比较会先拆箱比较数组,所以true
发表于 2021-10-09 23:16:26 回复(0)
new创建对象,两个new创建的是两个不同地址得对象,所以c1==c2会返回false
int型和integer比较会直接拆箱进行比较,比较的是数值;
注意装箱得范围
Integer.valueOf(int i) 返回的是缓存的Integer对象(并不是新建对象),变量所指向的是同一个对象,所以a1==a2返回true
发表于 2021-09-27 10:55:03 回复(0)
A:a1、a2赋值给Integer类型,自动装箱;范围在-128~127内,返回的是缓存的Integer对象,两个变量指向的是同一个对象,所以地址相同a1==a2
B:Integer和int类型进行比较时,会自动拆箱,拆成int,比较的是数值大小,所以d1==d2
C:b1、b2赋值给Integer类型,但由于超出-128~127范围,返回的是新建的对象,两个变量指向的地址不同,b1 != b2
D:普通new创建对象,创建出2个地址不同的对象,c1 != c2
发表于 2023-11-28 16:54:01 回复(0)
int和Integer比较,会进行自动装/拆箱,比较的是数值的大小; 2017超出了装/拆箱的范围(-128-127),所以比较的是内存地址。
发表于 2022-12-01 16:29:08 回复(0)
如果二者都是基础类型, == 比较的是值
如果是包装来类型或者引用类型, 比较的是内存地址
如果是包装类型和它对应的基础类型作比较, 如果在对应的范围内, 会从缓存中返回, 两个变量指向同一个地址, 不在对应范围就会在创建一个对象, 两个变量指向不同内存地址
equal只能比较引用类型, 而且只比较值
比较对象时, ==和equal都比较的内存地址
发表于 2022-04-16 13:22:38 回复(0)
<p>Java?</p><p><br></p>
发表于 2020-08-29 16:37:30 回复(0)

对于-128到127之间的数, Integer直接从数组中取, 故a1, a2指向的是同一个对象, A正确. 
其余都是new出来的对象, 显然地址都不相同.
int类型与Integer类型比较时, 先将Integer拆箱, 再比较值, 故B正确.
发表于 2024-03-24 22:27:58 回复(0)
整形数据缓存 最大值 127
编辑于 2024-03-06 16:27:36 回复(0)
2017超出了自动装箱缓存对象的范围
发表于 2023-11-14 21:53:00 回复(0)