java中INTEGER的取值范围

本是古典何须时尚 2022-03-08 14:10 286阅读 0赞

public static void main(String[] args) 
    	{
    		Integer a = new Integer(1);//此处若使用new，则a,b比较==值必为false
    		int c = 1;
    		Integer b = 1;
     
    		System.out.println(a == c); // true
    		System.out.println(a == b); // false
    		
    		Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
    		
    		System.out.println(f1 == f2); // true
    		System.out.println(f3 == f4); // false

为什么(f3 == f4); // false？

public class AutoboxingTest {
     
        public static void main(String args[]) {
     
            // Example 1: == comparison pure primitive – no autoboxing
            int i1 = 1;
            int i2 = 1;
            System.out.println("i1==i2 : " + (i1 == i2)); // true
     
            // Example 2: equality operator mixing object and primitive
            Integer num1 = 1; // autoboxing
            int num2 = 1;
            System.out.println("num1 == num2 : " + (num1 == num2)); // true
     
            // Example 3: special case - arises due to autoboxing in Java
            Integer obj1 = 1; // autoboxing will call Integer.valueOf()
            Integer obj2 = 1; // same call to Integer.valueOf() will return same
                                // cached Object
     
            System.out.println("obj1 == obj2 : " + (obj1 == obj2)); // true
     
            // Example 4: equality operator - pure object comparison
            Integer one = new Integer(1); // no autoboxing
            Integer anotherOne = new Integer(1);
            System.out.println("one == anotherOne : " + (one == anotherOne)); // false
     
        }
     
    }
     
    Output:
    i1==i2 : true
    num1 == num2 : true
    obj1 == obj2 : true
    one == anotherOne : false

**值得注意的是第三个小例子，这是一种极端情况。obj1和obj2的初始化都发生了自动装箱操作。但是处于节省内存的考虑，JVM会缓存-128到127的Integer对象。因为obj1和obj2实际上是同一个对象。所以使用”==“比较返回true。  
java在编译的时候 Integer a = 100; 被翻译成-> Integer a = Integer.valueOf(100);  
2。比较的时候仍然是对象的比较  
当不符合-128 127值范围时候。记住用的：new，开辟新的内存空间，不属于IntergerCache管理区。**

public static void main(String []args) {
        Integer a = 100;
        Integer b = a;//此时b指针指向值为100的堆地址  即a的堆地址，a==b成立
        a++;//此时a指向的值发生变化为101，a指针指向101的堆地址。而b任然指向100
        System.out.println(a==b);
    }

打印就是false

一个 Integer 类型占 4 字节，一个字节占 8 位二进制码，因此一个 Integer 总共占 32 位二进制码。去除第一位的符号位，剩下 31 位来表示数值。

**最小值为 -2^31，最大值为 2^31-1**

java中如果Integer不是new出Integer对象,而是直接赋值如：

Integer b1 = 12;
    
         Integer b2 = 12;

这种情况是在常量池中开辟出同一个空间来存储12，所以b1和b2都指向12，如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMwMjQyOTg3_size_16_color_FFFFFF_t_70]

接下来说说，Integer的缓冲范围，因为不是在堆区new一个对象，那么在常量池中就必须对其的大小范围做出一个规定，有一个规范叫JSL（Java Language Specification，java语言规范）对\*\*Integer的缓冲做了约束，规定其范围为：（-128-127）\*\*之间

**在计算机中，数据是由二进制补码进行存储的，在 Java 代码中我们看到的 “0x80000000”、“0x7fffffff”都是补码的形式，通过转换为原码获取它们的真实值。**  
转换公式：

*  **当原码为正数的时候，正数的原码、反码、补码都相同。**

正数：1  
原码：0000 0000 0000 0000 0000 0000 0000 0001  
反码：0000 0000 0000 0000 0000 0000 0000 0001  
补码：0000 0000 0000 0000 0000 0000 0000 0001

*  **当原码为负数的时候，反码为去除符号位按位取反，补码为去除符号位按位取反再加1。**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMwMjQyOTg3_size_16_color_FFFFFF_t_70]: /images/20220308/0da67bdb36394e9e87cb58d8b61e50f7.png