Java automatic boxing and unboxing source code analysis

What is packing & unboxing?

The process of converting the int basic type to the Integer packaging type is called boxing, and vice versa is called unboxing.

First look at a piece of code

public static void main(String[] args) {
    Integer a = 127, b = 127;
    Integer c = 128, d= 128;
    System.out.println(a == b); // true
    System.out.println(c == d); // false
}

I don’t know if anyone else doesn’t know why true and false appear in this code. From this we introduce the operation of Java boxing. We analyze with questions.

Boxing (valueOf())

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

We can find that there is a judgment at the beginning. If the value range is between [-128,127], then from this cache ( Integer array), if it is not in this range, just create a new one.

Why do we need a cache of [-128,127]?

I understand what I’m talking about, because in our business, there may be various Integer type fields such as status and identification. These values ​​​​are generally 0, 1, 2, 3 and the like, and they appear are relatively frequent. If there is no cache, then frequent new objects are needed and then released, which consumes a lot of memory space. Therefore, the cache appears, which can greatly help us optimize some waste of space.

Why is it [-128,127]?

I took a look at this. I won’t explain the specific reasons here. It mainly relies on basic computer knowledge. After you understand what the original code, inverse code, and complement code are. It is easy to know why it is in this range.

This value can also be changed through startup parameters.

-XX:AutoBoxCacheMax=(size)

Performance issues caused by automatic boxing

Now you should understand the reason why the above code has different results. So have you ever thought about, for example, in a for loop in our business, statistical data similar to this operation occurs. If there is automatic boxing, what problems will occur? Let's look at the following piece of code.

public static void main(String[] args) {
    long startTime = System.currentTimeMillis();
    Integer count = 0;
    // int count = 0;
    for (int i = 0; i < 5000000; i++) {
        count += i;
    }
    System.out.println("计算时长：" + (System.currentTimeMillis() - startTime) + " ms");
}

// 执行结果：
// Integer 计算时长：51 ms
// int 计算时长：6 ms

Then through the execution results, it can be clearly discovered that frequent new objects are automatically boxed and memory is allocated, causing performance losses in time and space.

Small Summary

Through the above source code reading and test analysis, we can draw the conclusion that we should try to avoid this type when we usually calculate statistics or enter parameters into methods. Conversion problem. To improve the execution efficiency of our entire code.

Unboxing (intValue)

There is no complicated logic in unboxing, and it directly returns the basic type of the value.

Supplement: Will automatic boxing and unboxing always happen?

Not necessarily. Look at the sample code below. The output results have been commented after the output statement.

public static void main(String[] args) {
// TODO 自动生成的方法存根
Integer a = 1;
Integer b = 2;
Integer c = 3;
Integer d = 3;
Integer e = 321;
Integer f = 321;
Long g = 3L;
System.out.println(c==d);//true
//包装类的==在没有遇到算术运算的情况下不会自动拆箱
System.out.println(e==f);//false
System.out.println(c==(a+b));//true
System.out.println(c.equals(a+b));//true
System.out.println(g==(a+b));//true
//equals方法不会处理数据转型关系
System.out.println(g.equals(a+b));//false
}

The situations where automatic boxing and unboxing occur are as follows:

Autoboxing: The basic type is assigned to the packaging type. For example: Integer i1 = 1;

Automatic unboxing:

1. The packaging type is assigned to the basic type. For example: int i2 = new Integer(1);

2. Compare the int type with the Integer type. If the values ​​of the int type and the Integer type are equal, the result is always true.

3. Integer type encounters arithmetic operations

But why in the above example, System.out.println(c==d); and System.out.println(e==f);The output results are different?

Mainly because of the Integer.valueOf() method. Part of the source code of Integer is posted below:

  //
   private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

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

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }
            private IntegerCache() {}
    }
    
  public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

IntegerCache is the static inner class of Integer, and valueOf() is the packaging method. As can be seen from the source code, cache is a cache array. When the input parameter i of the valueOf() method is in the range [-128,127], the Integer value in the cache array will be returned. Otherwise, a new Integer will be created.

This is the reason why the output results of System.out.println(c==d); and System.out.println(e==f); are different. c and d are in the cache interval, so they return the same reference; while e and f are not in the cache interval, they return new Integer, which is no longer the same reference.

The above is the detailed content of Java automatic boxing and unboxing source code analysis. For more information, please follow other related articles on the PHP Chinese website!