Java中Integer128的坑

目录

• 一、Integer和int的联系
• 1.1 Integer和int的区别
• 1.2 Integer和int的相互转换 
• 二、装箱
• 三、拆箱

今天在学习Java的时候遇到了下面几个问题。

public static void main(String[] args) {
        Integer num1 = 127;
        Integer num2 = 127;
        Integer num3 = 128;
        Integer num4 = 128;
        int num5 = 127;
        int num6 = 128;
        System.out.println(num1 == num2);
        System.out.println(num3 == num4);
        System.out.println(num1 == num5);
        System.out.println(num6 == num3);
    }

我会认为这个问题的输出结果是true、true、true、true。但是在运行的时候发现，结果并不是想象中的那样子。正确答案如下。

一、Integer和int的联系

Java 5 引入了自动装箱（Autoboxing）和拆箱（Unboxing）机制，允许 int 类型和 Integer 类型之间进行自动转换。

• 自动装箱：将 int 类型的值自动转换为 Integer 对象。
• 自动拆箱：将 Integer 对象自动转换为 int 类型的值。

1.1 Integer和int的区别

1. 类型不同

• int 是基本数据类型，直接存储整数值。

• Integer 是引用类型，存储的是对象的引用，指向堆内存中的 Integer 对象。

2. 内存使用

• int 变量在栈内存中直接存储整数值，占用的内存空间固定为 4 个字节。

• Integer 对象存储在堆内存中，除了存储整数值外，还需要额外的内存来存储对象的元数据，因此占用的内存空间相对较大。

3. 空值处理

• int 是基本数据类型，不能为 null。

• Integer 是引用类型，可以赋值为 null，这在某些需要表示 “无值” 的场景中非常有用。

1.2 Integer和int的相互转换 

在上一篇文章当中说到了类和对象，Integer并不是八大基本数据类型中的一个，Integer是一个类，类似于上一篇文章说到的学生类。

int转换为Intege：装箱

看下边一行代码。下边这行代码的执行涉及到了装箱操作。

Integer num1 = 127;

代码真正在执行的时候会变为下方的样子。这就是装箱操作，就是把一个基本类型的int变量，包装成一个引用类型的Integer变量。

Integer num1 = Integer.valueOf(127);

Integer转换为int：拆箱

下方的代码涉及到拆箱操作。

Integer num1 = 127;
int num2 = num1;

代码在执行的时候会变为这个样子。这就是拆箱操作。

Integer num1 = Ineger.valueOf(127);
int num2 = num1.intValue();

二、装箱

想要知道最开始的问题，就要具体了解，装箱到底是如何实现的，为什么对127装箱作比较是true，对128装箱后作比较是false，现在来跟进装箱的代码。

跟进到源码当中，我们发现这个方法对于我们传入的数值还进行了一次判断，i要和IntegerCache的low和high作比较，如果在low和high之前，那么就返回一个值，否则的话就返回一个new出来的Integer对象。

IntegerCache.low

能够看到，low其实是一个值，大小为-128

IntegerCache.high

同样的，high也是一个值，只不过好像没有初始值，这里我们先看做127。

对于一开始的问题，我们传进来的值是127。

 Integer num1 = 127;
 Integer num2 = 127;

 那么就会返回这个值。

 return IntegerCache.cache[i + (-IntegerCache.low)];

 IntegerCache.cache其实是一个Integer数组，用于存储一些Integer类创建出的对象。

那么它可以有哪些对象呢？看如下代码。

static {
            // high value may be pythonconfigured by property
            int h = 127;
            String integerCacheHighPropValue =
                VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    h = Math.max(parseInt(integerCacheHighPropValue), 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(h, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            // Load IntegerCache.archivedCache from archive, if possible
            CDS.initializeFromArchive(IntegerCache.class);
            int size = (high - low) + 1;

            // Use the archived cache if it exists and is large enough
        js    if (archivedCache == null || size > archivedCache.length) {
                Integer[] c = new Integer[size];
                int j = low;
                for(int i = 0; i < c.length; i++) {
                    c[i] = new Integer(j++);
                }
                archivedCache = c;
            }
            cache = archivedCache;
            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

 这是一个静态初始块，现在不讲太多，只是Integer类加载的时候会执行里边的代码，在这里有对cache的初始化。我们只需要关注下边的部分。

            int size = (high - low) + 1;

            // Use the archived cache if it exists and is large enough
            if (archivedCache == null || size > archivedCache.length) {
                Integer[] c = new Integer[size];
                int j = low;
                for(int i = 0; i < c.length; i++) {
                    c[i] = new Integer(j++);
                }
                archivedCache = c;
            }
            cache = archivedCache;

size就是我们设置的（127 + 128） + 1，也就是256。cache初始化的过程如下。

• 根据low和high计算size
• 初始化一个size大小的Integer数组
• 对数组进行赋值操作，也就是数组的0~255索引为存储的是-128http://www.devze.com~127之间的数字（包括0）

现在我们已经知道了，cache就是一个已经初始化好的数组，里边存储了-128~127之间的Integer对象的引用。那么回到上访的代码。如果我们传入的值在low~high之间，那么就会直接从这个cache中拿取已经创建好的Integer变量。

 return IntegerCache.cache[i + (-IntegerCache.low)];

现在有一点明白了，如果直接拿取的是已经创建好的对象，是不是就意味着每次拿的时候获取的都是同一个对象呢？就是这样子。

Integer num3 = 128;
Integer num4 = 128;

 如果传入的是128。那么就会通过new的方式来创建Integer对象，每次new出来的是一个全新的对象，所以通过new方式创建的对象在怎么比较也是false，因为引用类型对象之间用==操作，比较的是两个对象的地址是否相同，也就是说num3和num4比较的是他们在内存空间的地址是否是相同的，并非比较的他们的内容是否都是128。

而num1和num2的比较其实也是比较地址，但是因为num1和num2指向的是同一个对象，所以就是true。

三、拆箱

拆箱操作就很简单了，调用intValue()方法返回包装的整数。

public static www.devze.comvoid main(String[] args) {
        Integer num1 = 127;
        Integer num2 = 127;
        Integer num3 = 128;
        Integer num4 = 128;
        int num5 = 127;
        int num6 = 128;
        System.out.println(num1 == num2);  // Integer.valueOf(127) == Integer.valueOf(127)
        System.out.println(num3 == num4);  // Integer.valueOf(128) == Integer.valueOf(128)
        System.out.println(num1 == num5);  // num1.intValue() == 127
        System.out.println(num6 == num3);  // num2.intValue() == 128
    }

现在是否对这个问题了解的更多了一点呢。

到此这篇关于Java中Integer128的坑的文章就介绍到这了,更多相关Java Integer128内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)php！