Java Auto Boxing and unpacking those things

Basic data types for 1.JAVA

In Java, data types can be divided into two major types, Primitive type (base type) and reference type (reference type). The value of the base type is not an object, and methods such as ToString (), Hashcode (), GetClass (), Equals () of the object cannot be called. So Java provides a wrapper type for each of the basic types. As follows:

Java basic data Types

INDEX	Basic type	Size	Range of values	Default value	Package Type
1	Boolean	---	True,false	False	Boolean
2	Byte	8bit	-2^7--2^7-1	0	Byte
3	Char	16bit	\u0000-\UFFFF	\u0000	Character
4	Short	16bit	-2^15--2^15-1	0	Short
5	Int	32bit	-2^31--2^31-1	0	Integer
6	Long	64bit	-2^63--2^63-1	0	Long
7	Float	32bit	IEEE 754	0.0f	Float
8	Double	64bit	IEEE 754	0.0d	Double

2. Talking about unpacking and packing

Boxing is a variable that assigns an original data type to the corresponding encapsulated class. Unpacking is a variable that assigns a wrapper class variable to the corresponding primitive data type.

The automatic boxing and unpacking mechanism is introduced in Java 1.5:

(1) Auto-Boxing: The basic types are wrapped with their corresponding reference types, so that they have the characteristics of the object, you can call ToString (), Hashcode (), GetClass (), Equals () and other methods.

As follows:

Integer a=3;//This is auto-boxing

In fact, the compiler calls the static integer valueOf (int i) method, valueOf (int i) returns an Integer object representing the specified int value, then it becomes this:

Integer a=3; = = Integer a=integer.valueof (3);

2. Public static Integer valueOf (inti) {
4. if (i >=-&&i <=integercache.high)
6. //If I is between -128~high, the integer object of i is removed directly from the cache
8. return integercache.cache[i + 128];
10. Else
12. return new Integer (i); //Otherwise it is created in heap memory
14. }

(2) Unpacking: In contrast to automatic boxing, objects of reference types such as integers and double are re-simplified to the basic type of data.

As follows:

int i = new Integer (2);//This is unpacking.

The compiler internally calls Int intvalue () to return the int value of the integer object

1. public int intvalue () {
2. return value;
3. }

Note: Automatic boxing and unpacking is done by the compiler, and the compiler determines whether boxing and unboxing are performed at compile time based on syntax.

Java definition: When automatic boxing for values from –128 to 127, they are boxed into an integer object, there will be reuse in memory, there is always only one object
If the value from –128 to 127 is exceeded, the boxed integer object is not reused, which is equivalent to creating an integer object each time it is boxed;

1. Integer i1=100;
2. Integer i2=100;
3. Integer i3=300;
4. Integer i4=300;
5. System.out.println (I1==I2);
6. System.out.println (I3==I4);

Run the result as "System." out. println (I1==I2); " is true, but "System." out. println (I3==I4); " to False. This means that I1 and I2 refer to the same object for the two integer references, while i3 and I4 point to different objects. Why is it? Is it not all called the integer.valueof (int i) method?

2. Public static Integer valueOf (inti) {
4. if (i >=-&&i <=integercache.high)
6. //If I is between -128~high, the integer object of i is removed directly from the cache
8. return integercache.cache[i + 128];
10. Else
12. return new Integer (i); //Otherwise it is created in heap memory
14. }

We can see that when i>=-128 and I<=integercache.high, the Integercache is returned directly. Cache [i + 128]. Where Integercache is an integer internal static class with the original code as follows:

2. Private Static class Integercache {//inner class, note that its properties are defined as static final
4. static final Inthigh; //cache upper bound
6. static final Integer cache[]; Cache caching is an array that holds an integer type
10. Static {//statement block
12. final int low =-; Cache lower bound, value immutable
16. //High value could beconfigured by property
18. int h = 127; H value, which can be adjusted by setting the Autoboxcachemax parameter of the JDK (see (3))
20. if (integercachehighpropvalue! =null) {
22. //Use Long.decode This avoid invoking methods that
24. //Require Integer ' s autoboxing cache to be initialized
26. //By decoding Integercachehighpropvalue, and getting a candidate upper bound value
28. int i = Long.decode (integercachehighpropvalue). Intvalue ();
30. //Take a larger upper bound, but not greater than the integer boundary max_value
32. i = Math.max (i, 127); Upper bound minimum is 127
34. //Maximum array size is Integer.max_value
36. h = math.min (i, Integer.max_value--low);
38. }
40. High = h; //Upper bounds OK, at this time high default is generally 127
42. //Create cache block, note cache array size
44. cache =New integer[(high-low) + 1];
46. int j = Low;
48. For (int k = 0; k <cache.length; k++)
50. CACHE[K] =new Integer (j + +); -128 to high values are assigned to the cache array individually
52. }
56. Private Integercache () {}//constructor method, no need to construct anything
58. }

We can clearly see that Integercache has a static member variable cache, which is an array of 256 elements. The cache is also initialized in Integercache, where the I element is an integer object with a value of i-128. While 128 to 127 is the most commonly used integer object, this practice also improves performance to a large extent. Also because of this, "Integeri1=100;integer i2=100;", I1 and I2 get the same object.

Comparing the second experiment in the extension, we learned that when the encapsulation class is run with the underlying type = =, the wrapper class is disassembled, the unboxing result is compared with the underlying type, while the two wrapper classes are run as = = Run with other objects, comparing the addresses of two objects, It also determines whether two references point to the same object.

Extended:

The getandremovecacheproperties method, which gets or removes the cached properties of the JDK set for the integer, and can be adjusted by adjusting the virtual machine-xx:autoboxcachemax=<size> option. The size of the auto-boxing pool

2. Private static String Integercachehighpropvalue;
4. static void Getandremovecacheproperties () {
6. if (!sun.misc.vm.isbooted ()) {
8. Properties props= system.getproperties ();
10. Integercachehighpropvalue=
12. (String) Props.remove ("Java.lang.Integer.IntegerCache.high");
14. if (integercachehighpropvalue!=null)
16. System.setproperties (props); //Remove from System props
18. }
20. }

Set the-xx:autoboxcachemax=<size> option to test the code again <3>

In Eclipse, select the source file, right-click Run As->runconfiguratio--->arguments, and make the following settings in VM Arguments:

Java Auto Boxing and unpacking those things