• concept
• Constant pool
  • The benefits of constant pools
• Class constant pool in the Class file
  • Constant pool
    • Run-time constant pool
• Wrapper class constant pool Object pool
• Packing and unpacking in Java
  • assignment
  • Method call
  • Method operation
• reference

concept

What is a constant? Many of you are likely to blurt out that final variables are constants or strings defined at compile time. (String constant)

But this statement is not exact because, to be exact, constants are member variables that are final! Constants are loaded into the class’s constant pool at compile time.

Static variables can only be static variables. Local variables that are modified with final (within a method) can also be called immutable variables. (Stored on the stack)

Constant pool

The benefits of constant pools

Constant pool is to avoid frequent creation and destruction of objects that affect system performance, and it realizes object sharing. The string constant pool, for example, puts all string literals into one constant pool at compile time.

(1) Saving memory space: all the same string constants in the constant pool are merged and occupy only one space.

(2) Save runtime: == is faster than equals() when comparing strings. For two reference variables, only == is used to determine whether the references are equal, which can also determine whether the actual values are equal

The meaning of double equals == When a double equals sign is applied between basic data types, it is their numeric values that are compared. A double equal sign is applied between compound data types (classes) to compare where they reside in memory. (Reference address)

        String hello="helloMoto";   
        String hello2="helloMoto";  Copy the code

For example, we define hello and hello2, and the string constant “helloMoto” does not exist in the string constant pool. So we first create a “helloMoto” string object in the string constant pool, and hello points to the “helloMoto” string object in the string constant pool. The first line of code, Hello2, first looks for “helloMoto” in the constant pool, finds it already exists, and points directly to the “helloMoto” string object in the string constant pool. (String object exploration)

Class constant pool in the Class file

public class Test2 { public static void main(String[] args) { String hello="helloMoto"; }}Copy the code

Constant pool

The constant pool is used to store two main types of constants: literals and symbolic references

Literals are equivalent to Java language level constants, such as text strings, constant values declared final (member variables), and so on.

Symbolic references are a compilation principle and include three types of constants:

• Fully qualified names of classes and interfaces

• Field name and descriptor

• Method name and descriptor

Run-time constant pool

Wrapping class constant pool (object pool)

Basic types in the Java wrapper classes are mostly true constant pool technology, namely, Byte, Short, Integer, Long, Character, and Boolean; Float,Double

Integer i1 = 127; Integer i2 = 127; System.out.println(i1==i2); //true Integer i3 = 128; Integer i4 = 128; System.out.println(i3==i4); //falseCopy the code

For the above two pieces of code different results we can trace the Integer source code

//Integer

    public static Integer valueOf(int i) {
        if (i >= -128 && i <= 127)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }Copy the code

You can see that if the value is in the [-128,127] field, the IntegerCache class is used to cache the data, similar to string constant pools. So if a value is assigned outside the range, a new Integer object is created. (The advantage is that if Integer is used frequently and the value is in [-128,127], new Integer objects will not be created repeatedly.)

But there is no implementation of a constant pool (object pool) for the wrapper classes of the two basic data types Double and Float.

//Double


    public static Double valueOf(double d) {
        return new Double(d);
    }Copy the code

Packing and unpacking in Java

assignment

• If you want to generate an Integer object with a value of 10, you just need to do this:

Integer i = 10;Copy the code

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

• Split open a case

Integer i = 10; Int n = I; / / split open a caseCopy the code

Simply put, boxing automatically converts the base data type to the wrapper type; Unpacking automatically converts wrapper types to primitive data types.

Method call

public class Test2 { public static void main(String[] args) { int result = print(5); } private static int print(Integer a) {system.out.println ("a==" + a); return a; // Returns an int. Integer is automatically unpacked to an int. } } //a==5Copy the code

Method operation

public class Test2 { public static void main(String[] args) { Integer sum = 0; for (int i = 1000; i < 5000; I ++) {sum += I; sum += I; }}}Copy the code

Sum += I = sum+ I = sum+ I = sum+ I = sum+ I = sum+ I = sum+ I = sum+ I = sum+ I = sum+ I = sum+ I The internal changes are as follows

int result = sum.intValue() + i;
Integer sum = new Integer(result);Copy the code

Since the sum declared here is of type Integer, the above loop creates approximately 4000 useless Integer objects, which can degrade program performance and increase garbage collection efforts in such a large loop. So when we program, we need to be aware of this and declare variable types correctly to avoid performance problems caused by automatic boxing.

reference