Java Enclosures and unpacking

A. What is boxing? What is unpacking?

Two. How the packing and unpacking is achieved

Three. Questions related to the interview

A. What is boxing? What is unpacking?

As mentioned in the previous article, Java provides a wrapper type for each of the basic data types, as for why the wrapper type for each of the basic data types is not elaborated here, and interested friends can access the relevant information. Before Java SE5, if you want to generate an integer object with a numeric value of 10, you must do this:

Integer i = newInteger(10);

The auto-boxing feature is provided at the beginning of Java SE5, if you want to generate an integer object with a numeric value of 10, this is all you need:

Integer i = 10;

This process automatically creates the corresponding integer object based on the value, which is the boxing.

So what is unpacking? As the name implies, it corresponds to boxing, which is to automatically convert the wrapper type to the basic data type:

Integer i = 10;  //装箱

int n = i;    //拆箱Simply put, boxing is the automatic conversion of the base data type to the wrapper type; unpacking is the automatic conversion of the wrapper type to the base data type.

Int (4 bytes)	Integer
Byte (1 bytes)	Byte
Short (2 bytes)	Short
Long (8 bytes)	Long
Float (4 bytes)	Float
Double (8 bytes)	Double
Char (2 bytes)	Character
Boolean (Undecided)	Boolean

Next, find out how boxing and unpacking are implemented. public class Main {      public static void main(String[] args) {                   Integer i =  10 ;          int n = i;      } }After you decompile the class file, you get the following:

The content of the bytecode obtained from the decompile can be seen as an integer valueof (int) method that is automatically called when boxing. The Intvalue method of integer is called automatically when unpacking.

Other similar, such as Double, Character, do not believe that friends can manually try.

So you can summarize the process of packing and unpacking in a sentence:

The boxing process is implemented by calling the wrapper's ValueOf method, and the unboxing process is implemented by invoking the wrapper's Xxxvalue method. (XXX represents the corresponding basic data type).

Three. Questions related to the interview

While most people are clear about the concept of boxing and unpacking, the question of packing and unpacking in interviews and written tests does not necessarily answer. Here are some common questions related to packing/unpacking.

1. What is the output of the following code?

The answer is I1=I2 true;

I3=i4 false;

Why do you have such a result? The output shows that I1 and I2 point to the same object, while i3 and I4 point to different objects.

Just a look at the source code will know, the following is the implementation of the ValueOf method of Integer.

When you create an integer object by using the ValueOf method, if the value is between [-128,127], a reference to the object that already exists in Integercache.cache is returned, otherwise a new integer object is created.

The values for I1 and I2 in the above code are 100, so the objects that already exist are taken directly from the cache, so i1 and I2 point to the same object, while i3 and I4 point to different objects respectively.

2. What is the output of the following code?

False
False

As for the specific why, the reader can go to see the valueof of the double class.

This explains why the valueof method of the double class takes on a different implementation than the ValueOf method of the integer class. It is simple: the number of integer values in a range is limited, but floating-point numbers are not.

Note that the implementations of the valueof methods of the classes Integer, short, Byte, Character, long are similar.

The implementation of the valueof method of Double and float is similar.

Boolean i11 = false;
Boolean i21 = false;
Boolean i31 = true;
Boolean i41 = true;

System.out.println (I11==I21);
System.out.println (i31==i41);

True
True

4. Talk about the integer i = new integer (XXX) and integer i =xxx, the difference between the two ways.

Of course, this topic belongs to a relatively broad category. But the main point must be answered, I summed up the following two points are the difference:

1) The first way does not trigger the automatic boxing process, while the second method will trigger;

2) difference in execution efficiency and resource occupancy. The second approach is more efficient and resource-intensive than the first case in general (note that this is not absolute).

    Integer a =  1 ;          Integer b =  2 ;          Integer c =  3 ;          Integer d =  3 ;          Integer e =  321 ;          Integer f =  321 ;          Long g = 3L;          Long h = 2L;                   System.out.println(c==d);          System.out.println(e==f);          System.out.println(c==(a+b));          System.out.println(c.equals(a+b));          System.out.println(g==(a+b));          System.out.println(g.equals(a+b));          System.out.println(g.equals(a+h));

True
False
True
True
True
False
True

It is important to note that when the two operands of the "= =" operator are references to the wrapper type, it is whether the comparison points to the same object, and if one of the operands is an expression (that is, the arithmetic operation is included), the value is compared (that is, the process that triggers the automatic unboxing). Also, for wrapper types, the Equals method does not convert the type. After understanding these 2 points, the above output will be at a glance.

The first and second outputs have no doubt. The third sentence because a+b contains arithmetic operations, it triggers the automatic unboxing process (which calls the Intvalue method), so they compare the values for equality. And for C.equals (A+B) will trigger the automatic unpacking process, and then trigger the automatic boxing process, that is a+b, will call the Intvalue method, the addition operation after the value, then call the Integer.valueof method, then the equals comparison. The same is true for the latter, but pay attention to the result of the second and last output (if the value is of type int, the boxing procedure calls integer.valueof; if it is a long type, the Long.valueof method of the boxing call).

Java Enclosures and unpacking