Integer 缓存机制（JDK 17 源码）

1@jdk.internal.ValueBased
2public final class Integer extends Number
3        implements Comparable<Integer>, Constable, ConstantDesc {

 1public class IntegerCacheVerify {
 2    public static void main(String[] args) {
 3        Integer a = 10;                 // 编译为 Integer.valueOf(10)
 4        Integer b = 10;
 5        Integer c = Integer.valueOf(10);
 6        System.out.println("a == b (10): " + (a == b));
 7        System.out.println("a == c (10): " + (a == c));
 8
 9        Integer d = 127;
10        Integer e = 127;
11        System.out.println("127 == : " + (d == e));
12
13        Integer f = 128;
14        Integer g = 128;
15        System.out.println("128 == : " + (f == g));
16        System.out.println("128 equals : " + (f.equals(g)));
17
18        Integer h = -128;
19        Integer i = -128;
20        System.out.println("-128 == : " + (h == i));
21
22        Integer j = -129;
23        Integer k = -129;
24        System.out.println("-129 == : " + (j == k));
25
26        @SuppressWarnings("removal")
27        Integer n = new Integer(10);
28        System.out.println("new(10) == valueOf(10): " + (n == Integer.valueOf(10)));
29
30        Integer p = 1000;
31        Integer q = 1000;
32        System.out.println("1000 == : " + (p == q));
33    }
34}

1javac IntegerCacheVerify.java
2java IntegerCacheVerify

1a == b (10): true
2a == c (10): true
3127 == : true
4128 == : false
5128 equals : true
6-128 == : true
7-129 == : false
8new(10) == valueOf(10): false
91000 == : false

1java -XX:AutoBoxCacheMax=1000 IntegerCacheVerify

1a == b (10): true
2a == c (10): true
3127 == : true
4128 == : true
5128 equals : true
6-128 == : true
7-129 == : false
8new(10) == valueOf(10): false
91000 == : true

 1/**
 2 * Cache to support the object identity semantics of autoboxing for values between
 3 * -128 and 127 (inclusive) as required by JLS.
 4 *
 5 * The cache is initialized on first usage.  The size of the cache
 6 * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
 7 * During VM initialization, java.lang.Integer.IntegerCache.high property
 8 * may be set and saved in the private system properties in the
 9 * jdk.internal.misc.VM class.
10 *
11 * WARNING: The cache is archived with CDS and reloaded from the shared
12 * archive at runtime. The archived cache (Integer[]) and Integer objects
13 * reside in the closed archive heap regions. Care should be taken when
14 * changing the implementation and the cache array should not be assigned
15 * with new Integer object(s) after initialization.
16 */

 1private static class IntegerCache {
 2    static final int low = -128;
 3    static final int high;
 4    static final Integer[] cache;
 5    static Integer[] archivedCache;
 6
 7    static {
 8        // high value may be configured by property
 9        int h = 127;
10        String integerCacheHighPropValue =
11            VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
12        if (integerCacheHighPropValue != null) {
13            try {
14                h = Math.max(parseInt(integerCacheHighPropValue), 127);
15                // Maximum array size is Integer.MAX_VALUE
16                h = Math.min(h, Integer.MAX_VALUE - (-low) -1);
17            } catch( NumberFormatException nfe) {
18                // If the property cannot be parsed into an int, ignore it.
19            }
20        }
21        high = h;
22
23        // Load IntegerCache.archivedCache from archive, if possible
24        CDS.initializeFromArchive(IntegerCache.class);
25        int size = (high - low) + 1;
26
27        // Use the archived cache if it exists and is large enough
28        if (archivedCache == null || size > archivedCache.length) {
29            Integer[] c = new Integer[size];
30            int j = low;
31            for(int i = 0; i < c.length; i++) {
32                c[i] = new Integer(j++);
33            }
34            archivedCache = c;
35        }
36        cache = archivedCache;
37        // range [-128, 127] must be interned (JLS7 5.1.7)
38        assert IntegerCache.high >= 127;
39    }
40
41    private IntegerCache() {}
42}

1/*
2 * WARNING: This method may be invoked early during VM initialization
3 * before IntegerCache is initialized. Care must be taken to not use
4 * the valueOf method.
5 */

 1/**
 2 * Returns an {@code Integer} instance representing the specified
 3 * {@code int} value.  If a new {@code Integer} instance is not
 4 * required, this method should generally be used in preference to
 5 * the constructor {@link #Integer(int)}, as this method is likely
 6 * to yield significantly better space and time performance by
 7 * caching frequently requested values.
 8 *
 9 * This method will always cache values in the range -128 to 127,
10 * inclusive, and may cache other values outside of this range.
11 *
12 * @param  i an {@code int} value.
13 * @return an {@code Integer} instance representing {@code i}.
14 * @since  1.5
15 */
16@IntrinsicCandidate
17public static Integer valueOf(int i) {
18    if (i >= IntegerCache.low && i <= IntegerCache.high)
19        return IntegerCache.cache[i + (-IntegerCache.low)];
20    return new Integer(i);
21}

1@Deprecated(since="9", forRemoval = true)
2public Integer(int value) {
3    this.value = value;
4}

1public boolean equals(Object obj) {
2    if (obj instanceof Integer) {
3        return value == ((Integer)obj).intValue();
4    }
5    return false;
6}

1public static Integer valueOf(String s) throws NumberFormatException {
2    return Integer.valueOf(parseInt(s, 10));
3}