Integer

Integer.valueOf()

源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
   
@IntrinsicCandidate
   public static Integer valueOf(int i) {
       if (i >= IntegerCache.low && i <= IntegerCache.high)
           return IntegerCache.cache[i + (-IntegerCache.low)];
       return new Integer(i);
   }

//缓存-128-127区间的数值
private static class IntegerCache {
       static final int low = -128;
       static final int high;
       static final Integer[] cache;
       static Integer[] archivedCache;

       static {
           // high value may be configured 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
           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;
       }

       private IntegerCache() {}
   }

Integer a=100

将int赋值给Integer封装类，Java会默认进行一个装箱操作，将100包装成Integer类

字节码

1
2
3
4
0 bipush 100
2 invokestatic #7 <java/lang/Integer.valueOf : (I)Ljava/lang/Integer;>
5 astore_1
6 return

在Integer内部中用到了享元模式的思想，通过复用对象，减少对象创建数量，从而减少内存占用和提升性能

1
2
3
4
5
6
Integer a=127;
Integer b=127;
Integer c=128;
Integer d=128;
System.out.prinltn(a==b); //true
System.out.prinltn(a==b); //false