求助 一个java基础问题

Question

public class Test{
public static void main(String[] args){
Integer a = 100 ;
Integer b = 100 ;

Integer a2 = 200;
Integer b2 = 200;


System.out.println (a==b);

System.out.println (a2==b2);
}
}输出的结果是true ,false 不知道为什么

Answer 1

Integer的范围在 [-128,127]
直接赋值的Integer当值的范围的时候，
不会生成新的对象，直接把缓存中的对象拿来用可以看看Integer的源代码 里面有实现

Answer 2

这是 java 5的新特性，基本数据类型的自动装箱和拆箱的问题，
如果是 Integer  a2 = new Integer(200);Integer b2 = new Integer(200);
这样打出来就是false

Answer 3

有这种问题吗、？奇诡哦，我运行时也是这个问题哦，这个结果应该是相同才对的啊。a2 b2 的值都改为100后又是true，true这个问题看来非研究java虚拟机而解决不可啦

Answer 4

你调试进去就知道了，Integer会自动缓存[-128,127]之间的Integer对象，
而Integer a=100调用的是函数Integer.valueOf(int),该函数对于这个
范围内的整数缓存起来并返回同一个实例，而之外的则每次创建一个新对象

Answer 5

楼主你写的代码就有问题啊 
Integer a = 100 ;
Integer b = 100 ;
        
Integer a2 = 200;
Integer b2 = 200;
都是错误的（int转化integer）
估计你是想问的是==和equals的区别吧
如String str="2";
String str1="2";System.out.println (str==str1);//结果是true
System.out.println (str.equal(str1);//结果是true  
//str 和str1指向的是同一个内存空间所以怎么比较他就是相等的而 String ss=new String();
String sss=new String();
System.out.print(ss==sss);//false
System.out.print(ss.equals(sss));//true
//在堆内存中分配了两个不同的内存空间 而equal只是比较2个值是否相等所以是true其实==比较的引用是否相等
而equal比较的是两个数的值是否相等
记住这一句话就可以了

Answer 6

应当输出false,因为他们指向不同的对象，

Answer 7

你调试进去就知道了，Integer会自动缓存[-128,127]之间的Integer对象， 
而Integer a=100调用的是函数Integer.valueOf(int),该函数对于这个 
范围内的整数缓存起来并返回同一个实例，而之外的则每次创建一个新对象

Answer 8

我用程序运行了一遍，结果和楼主所说的一样。
在调试的过程中发现，装包中的Integer的自动缓存在[-128,127]之间，与前面三楼和六楼说的一样，如果超出这个范围，则比较的值结果为FALSE；否则为TRUE。

Answer 9

char 的范围才是-128到128之间   Integer是包装类    ==判断的是内容  而equals判断的是地址  如果你是NEW 出来的那么是FALSE  因为他们指向的对象的地址是不相同的    1.5以后可以直接用Integer   而1.5以前不能这么用  要进行转换

Answer 10

这个问题我老师有讲过
装箱时，Integer型的赋值不大于１００时，
两个该类型的数据装箱后就有可能相等
而大于１００的，就会不相等

Answer 11

那个范围是１２７，我刚才又试了一下
只要大于１２７就会输出false
你自己再试试吧

Answer 12

        Integer a = 100 ;
        Integer b = 100 ;
        Integer a2 = 200 ;
        Integer b2 = 200 ;
        Integer a3 = new Integer(100) ;
        Integer b3 = new Integer(100) ;
        System.out.println (a==b);
        System.out.println (a2==b2);
        System.out.println(a3==b3);输出结果如下：true
false
false由输出结果可知：9楼的说法应该是正确的，即：Integer会自动缓存[-128,127]之间的Integer对象， 而Integer a=100调用的是函数Integer.valueO(int),该函数对于这个 范围内的整数缓存起来并返回同一个实例，而之外的则每次创建一个新对象

Answer 13

 在上诉范围内时,如果已经有了一个,则不再生成一个新的对象,所以a==b,因为他们引用同一个对象
超出范围后,就不再是这样了,所以a2!=b2,因为他们是俩个对象

Answer 14

关键是两段代码，一个是valueOf方法实现boxing（可以从字节码中看出来调用了这个方法）public static Integer valueOf(int i) {
final int offset = 128;
if (i >= -128 && i <= 127) { // must cache 
    return IntegerCache.cache[i + offset];
}
        return new Integer(i);
    }然后是，内部类IntegerCache，缓存了Integer对象：private static class IntegerCache {
private IntegerCache(){} static final Integer cache[] = new Integer[-(-128) + 127 + 1]; static {
    for(int i = 0; i < cache.length; i++)
cache[i] = new Integer(i - 128);
}
    }
 

Answer 15

byte 类型的数据会被系统缓冲，也就是共享。所以 128以内的都会这样。 你可以测试看看127 = true
128 = false;没啥特殊的

Answer 16

Integer会自动缓存[-128,127]之间的Integer对象

Answer 17

首先
public class Test {
public static void main(String[] args) {
Integer a = 100;  //自动包装（或叫自动装箱）
Integer b = 100;  //编译器会将其处理成 Integer b = Integer.valueOf(100);
Integer a2 = 200;
Integer b2 = 200;
System.out.println (a == b);
System.out.println (a2 == b2);
}
}
剩下的可以从 Integer.valueOf() 源代码里找到答案，如下：
public static Integer valueOf(int i) {
final int offset = 128;
//注意下面的这个 if，如果在 -128 ~ 127 间就用缓冲的 Integer 对象的引用作返回值
if (i >= -128 && i <= 127) {  // must cache
return IntegerCache.cache[i + offset];
}
return new Integer(i);
}

Answer 18

你的 jdk版本 过低 只有 1.5之后的才能编译通过

Answer 19

byte 类型的数据会被系统缓冲，也就是共享。 
所以 128以内的都会这样。 你可以测试看看 
127 = true 
128 = false; 
没啥特殊的 

Answer 20

Integer会自动缓存[-128,127]之间的Integer对象

Answer 21

上面的是Integer的原代码，所以可以很清楚明白是什么问题，但是一般我们不会象帖主那样去定义的。