Java Constant Pool Concept

In the class file, "constant pool" is the most complex and most noteworthy content.

Java is a dynamically connected language, the role of a constant pool is very important, in addition to the constant pool contains the various basic types defined in the code (such as int, long, and so on) and the object type (such as string and array) of the constant value also contains some of the textual form of symbolic references, such as:

The fully qualified name of the class and interface;

The name and descriptor of the field;

Methods and names and descriptors.

In C, if a program calls a function in another library, the position of the function in the library (that is, the offset from the beginning of the library file) is written in the program at the time of the connection, and the function is called directly to the address at runtime;

In the Java language, this is not the case, and everything is dynamic. At compile time, if a call to another class method or a reference to another class field is found, the record into the class file can only be a symbolic reference in text form, and during the connection, the virtual machine will find the corresponding method or field according to the text information.

So, unlike the so-called "constants" in the Java language, the "constant" content in a class file is not rich, and these constants are concentrated in one area of the class, followed by one, which is called a "constant pool."

The constant pool technique in Java, which occurs when an object is needed, can be taken out of the pool (if one is not created in the pool), and it will save a lot of time when you need to repeat the creation of equal variables. A constant pool is actually a memory space, unlike the heap space where objects created with the New keyword are located. This article only discusses Java constant pool technology from the Java user's point of view, and does not involve the principle and implementation method of constant pool. Personally, if you are really focused on Java, you have to have a certain understanding of these details. But it is not necessary to know the principle and the concrete way to implement it.

Objects in a constant pool and objects in a heap

[Java]View Plaincopy

2. Public class test{
6. Integer i1=New Integer (1);
8. Integer i2=New Integer (1);
10. I1,i2 in different memory spaces in the heap, respectively
14. System.out.println (I1==I2); //Output False
20. Integer i3=1;
22. Integer i4=1;
24. I3,i4 points to the same memory space in a constant pool
28. System.out.println (I3==I4); //Output True
32. Obviously, I1,i3 is in a different memory space.
36. System.out.println (I1==I3); //Output False
40. }

8 basic types of wrapper classes and object pools

Most of the basic types of wrapper classes in Java implement the constant pool technique, which is byte,short,integer,long,character,boolean, and the other two types of floating-point wrapper classes are not implemented. Also byte,short,integer,long,character these 5 types of integer wrapper classes can use object pooling only when the corresponding value is less than or equal to 127, which is why the object is not responsible for creating and managing objects greater than 127 of these classes. Here are some of the corresponding test codes:

[Java]View Plaincopy

2. Public class test{
6. Public static void Main (string[] args) {
10. ///5 kinds of Byte,short,integer,long,character objects of plastic packaging class,
14. //You can use a constant pool when the value is less than 127
18. Integer i1=127;
22. Integer i2=127;
26. System.out.println (I1==I2)//Output True
30. //value is greater than 127, object is not taken from the constant pool
34. Integer i3=128;
38. Integer i4=128;
42. System.out.println (I3==I4)//Output False
46. the//boolean class also implements the constant pool technology
50. Boolean bool1=true;
54. Boolean bool2=true;
58. System.out.println (bool1==bool2); //Output True
62. //floating-point type wrapper class does not implement constant pool technology
66. Double d1=1.0;
70. Double d2=1.0;
74. System.out.println (D1==D2)//Output False
82. }
86. }

String also implements the constant pool technique

The string class is also a much-used class in Java, and also implements the technique of constant pooling for the convenience of creating a String object, the test code is as follows:

[Java]View Plaincopy

2. Public class test{
6. Public static void Main (string[] args) {
10. S1,s2 in different spaces in the heap
14. String s1=new string ("Hello");
18. String s2=new string ("Hello");
22. System.out.println (S1==S2)//Output False
26. S3,S4 in the same space in the pool
30. String s3="Hello";
34. String s4="Hello";
38. System.out.println (S3==S4); //Output True
42. }
46. }

At last

Details determine success or failure, and writing code is more so.

Before JDK5.0, it is not allowed to directly assign the data of the basic data type directly to its corresponding wrapper class, such as: Integer i = 5;

However, this notation is supported in JDK5.0 because the compiler will automatically convert the above code into the following code: Integer i=integer.valueof (5);

This is the boxed java. The JDK5.0 also offers automatic unpacking. Integer i = 5; int j = i;

Integer encapsulation:

[Java]View Plaincopy

2. Public static Integer valueOf (int i) {
4. final int offset = 128;
6. if (i >=-&& i <= 127) { //must cache
8. return integercache.cache[i + offset];
10. }
12. return new Integer (i);
14. }
20. Private static class Integercache {
28. Private Integercache () {}
30. Static final Integer cache[] = new integer[-(-+) + 127 + 1];
32. Static {
34. For (int i = 0; i < cache.length; i++)
36. Cache[i] = new Integer (i- 128);
38. }
40. }

Because cache[] is a static array in the Integercache class, that is, it only needs to be initialized once, that is, static{... } section, so if the integer object is initialized with a range of -128~127, there is no need to redefine the application space, which is the same object---in Integercache.cache, which can improve the efficiency to some extent.

Java Constant Pool Concept