Cache for Java integer classes

First look at a piece of code (using JDK 5), as follows:

[HTML]View PlainCopy

2. public class Hello
4. {
6. public static void Main (string[] args)
8. {
10. int A = + , B = 1000;
12. System.out.println (a = = b);
16. Integer C = N, d = 1000;
18. System.out.println (c = = d);
22. Integer e = + , f = 100;
24. System.out.println (E = = f);
26. }
28. }

Output Result:

[HTML]View PlainCopy

1. True
2. False
3. True

the Java Language specification, 3rd Edition wrote:

[HTML]View PlainCopy

1. To save memory, for two instances of the following wrapper objects, when their base values are the same, they are always = =:
2. Boolean
3. Byte
4. Character, \u0000-\u007f (7f is the decimal 127)
5. Integer,-128-127

View the JDK source code as follows:

[Java]View PlainCopy

2. /**
4. * Cache to support the object identity semantics of autoboxing for values between
6. * -128 and 127 (inclusive) as required by JLS.
8. *
10. * The cache is initialized on first usage. During VM Initialization the
12. * Getandremovecacheproperties method May is used to get and remove any system
14. * Properites that configure the cache size. At this time, the size of the
16. * Cache May is controlled by the VM Option-xx:autoboxcachemax=<size>.
18. */
22. //value of Java.lang.Integer.IntegerCache.high property (obtained during VM init)
24. private static String Integercachehighpropvalue;
28. static void Getandremovecacheproperties () {
30. if (!sun.misc.vm.isbooted ()) {
32. Properties props = System.getproperties ();
34. Integercachehighpropvalue =
36. (String) Props.remove ("Java.lang.Integer.IntegerCache.high");
38. if (integercachehighpropvalue! = null)
40. System.setproperties (props); //Remove from System props
42. }
44. }
48. private static class Integercache {
50. static final int high;
52. static final Integer cache[];
56. Static {
58. final int low =-128;
62. //High value is configured by property
64. int h = 127;
66. if (integercachehighpropvalue! = null) {
68. //Use Long.decode This avoid invoking methods that
70. //Require Integer ' s autoboxing cache to be initialized
72. int i = Long.decode (integercachehighpropvalue). Intvalue ();
74. i = Math.max (i, 127);
76. //Maximum array size is Integer.max_value
78. h = math.min (i, Integer.max_value--low);
80. }
82. High = h;
86. cache = New integer[(high-low) + 1];
88. int j = Low;
90. For (int k = 0; k < cache.length; k++) //Buffer room data
92. CACHE[K] = new Integer (j + +);
94. }
98. Private Integercache () {}
100. }
104. /** 
106. * Returns A <tt>Integer</tt> instance representing the specified
108. * <tt>int</tt> value.
110. * If A new <tt>Integer</tt> instance isn't required, this method
112. * Should generally be used on preference to the constructor
114. * {@link #Integer (int)}, as this method was likely to yield
116. * Significantly better space and time performance by caching
118. * Frequently requested values.
120. *
122. * @param i an <code>int</code> value.
124. * @return A <tt>Integer</tt> instance representing <tt>i</tt>.
126. * @since 1.5
128. */
130. public static Integer valueOf (int i) {
132. if (i >=-&& i <= integercache.high)
134. return integercache.cache[i + 128];
136. Else
138. return new Integer (i);
140. }

The integercache here has a static integer array that, when the class loads, creates a 128 to 127 integer object and saves it in the cache array once the program calls the ValueOf method, if the value of I is 128 to 127 The integer object is taken directly between the cache buffer array.

And look at the other wrappers:

• Boolean: (full cache)
• Byte: (Cache All)
• Character (<= 127 cache)
• Short (-128-127 cache)
• Long (-128-127 cache)
• Float (no cache)
• Doulbe (no cache)

Also for the garbage collector:

[Java]View PlainCopy

1. Integer i = 100;
2. i = null;   Would not do any of the object available for GC at all.

The code here does not have objects that conform to the garbage collector's condition, where I is given null, but it points to an integer object in the cache, and the cache is not assigned null, so an integer (100) object is still present.

If I is greater than 127 or less than-128, the object it points to will be eligible for garbage collection:

[Java]View PlainCopy

1. Integer i = 10000;
2. i = null;   Would make the newly created an Integer object available for GC.

Cache for Java integer classes (RPM)