Analyzing the invariance of Integer type parameter value to understand Java value parameter passing

Previously on java There are some doubts about the reference passing of value Integer and String The method is passed in to modify, but the final value is not modified. Now, after continuous learning, I have some new experience here. Now I summarize.

Code process

(1) Code first

private void add(Integer i) {
        i = i - 1;
    }

    private void reverse(String s) {
        s = "sey";
    }

    public static void main(String[] args) {
        Integer i = 1;
        String s = "yes";
        Test test = new Test();
        test.add(i);
        test.reverse(s);

        // Print value
        System.out.println(String.format("i Value of:%d", i));
        System.out.println(String.format("s Value of:%s", s));
    }

(2) The printing results are as follows:

You can see that the value has not changed. Next, let me analyze why.
(3) Decompile as follows:

public class Test
{

	public Test()
	{
	}

	private void add(Integer i)
	{
		i = Integer.valueOf(i.intValue() - 1);
	}

	private void reverse(String s)
	{
		s = "sey";
	}

	public static void main(String args[])
	{
		Integer i = Integer.valueOf(1);
		String s = "yes";
		Test test = new Test();
		test.add(i);
		test.reverse(s);
		System.out.println(String.format("i Value of:%d", new Object[] {
			i
		}));
		System.out.println(String.format("s Value of:%s", new Object[] {
			s
		}));
	}
}

We can clearly see that due to the java syntax sugar, Integer i = 1; Essentially Integer.valueOf(1). Then go deep into the Integer source code:

Familiar friends will know that Integer has a cache of - 128-127. Within this interval, it will directly get the cache from IntegerCache and return. Beyond this interval, it will return a new object.

Principle analysis

This time I will discuss from the of virtual machine stack and heap:
First, the JVM model is as follows:

(1) Display specific bytecode

implement javap -c Test.class The command decomposes the method code and displays the specific bytecode of each method

public class Test {
  public Test();
    Code:
       0: aload_0							// Load variables at local variable table [0] (usually this object)
       1: invokespecial #1 / / initialization method
       4: return							// Method end

  public static void main(java.lang.String[]);
    Code:
       0: iconst_1							// Pushes the constant 1 onto the operand stack
       1: invokestatic  #3 / / Boxing (Integer.valueOf()), returns an object and pushes it to the top of the stack
       4: astore_1							// The top element of the stack goes out of the stack and stores the reference in the local variable table [1]
       5: ldc           #5 / / String yes push the items in the constant pool onto the stack
       7: astore_2							// The top element of the stack goes out of the stack and stores the reference in the local variable table [2]
       8: new           #6 / / create a Test object (allocate memory on the heap and return a reference), and push the reference to the top of the stack
      11: dup								// The stack top element is out of the stack, and the stack top element is copied
      12: invokespecial #7 / / the top element of the stack is out of the stack, and the instantiation init() method is called
      15: astore_3							// The top element of the stack is out of the stack and will refer to the location where the local variable table [3] exists
      16: aload_3							// Load reference of local variable table [3] - > corresponding test
      17: aload_1							// Load reference of local variable table [1] - > corresponding i
      18: invokespecial #8 / / call the instantiation method test and add()
      21: aload_3							// Loading references to local variable table [3]
      22: aload_2							// Loading references to local variable table [2]
      23: invokespecial #9 / / call the instantiation method test and reverse()
      26: getstatic     #10                 // Field java/lang/System.out:Ljava/io/PrintStream;
      29: ldc           #11 / / value of string I:% d
      31: iconst_1
      32: anewarray     #12                 // class java/lang/Object
      35: dup
      36: iconst_0
      37: aload_1
      38: aastore
      39: invokestatic  #13                 // Method java/lang/String.format:(Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;
      42: invokevirtual #14                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      45: getstatic     #10                 // Field java/lang/System.out:Ljava/io/PrintStream;
      48: ldc           #15 / / value of string:% s
      50: iconst_1
      51: anewarray     #12                 // class java/lang/Object
      54: dup
      55: iconst_0
      56: aload_2
      57: aastore
      58: invokestatic  #13                 // Method java/lang/String.format:(Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;
      61: invokevirtual #14                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      64: return
}

(2) We know that the Java virtual machine is thread private. When each method is executed, the Java virtual machine will synchronously create a stack frame to store the local variable table, operand stack, dynamic link, method exit and other information. The process from the call of each method to the completion of execution corresponds to the process of a stack frame from stack entry to stack exit in the virtual machine stack, This time, we will discuss the stack frames of the two methods of the virtual machine stack: main(), add().

(3) As shown in the figure, main corresponds to a stack frame. The local variable table element i in the stack frame points to i in the heap and s points to s in the heap.

When line 18 of bytecode is executed in the main() method: invokespecial #8 / / call the instantiation method test and add() method
Because Java is passed by reference, the reference address of i in the local variable table is passed to the i parameter in the add() method of the instantiated object test. At the same time, the add() method is called, and the stack frame of the add() method is pressed into the Java Virtual machine stack. At the same time, the stack frame has its own local variable table i, which points to the memory i in the heap.

Because i is a local variable at this time, it only exists in the stack frame of add when executing the code

 i = i - 1;(Equivalent to execution  i = Integer.valueOf(i - 1) )；

As shown in the figure, in the local variable table in the stack frame of the add() method, i memory points to i1.

To sum up, we can see that the memory address of the local variable table i in the stack frame of the original main() method has not changed, so it will not change when printing. Only the memory address in the heap pointed to by i in the local variable table in the add() stack frame is changed, which will not affect the i in the local variable table of the main() method.

summary

The transfer method in Java is reference transfer. If you want to modify the value of a variable in a method, you can only modify the value of the original variable pointing to the memory in the heap, not by changing the reference address of the object in the method.

public class Test {

    Integer x = 1;
    Integer y = 2;

    /**
     * Exchange variable
     */
    private void swap(Integer i1, Integer i2) {
        i1 = i1 ^ i2;
        i2 = i1 ^ i2;
        i1 = i1 ^ i2;
    }

    private void swap(Test test) {
        Integer x = test.x;
        Integer y = test.y;
        x = x ^ y;
        y = x ^ y;
        x = x ^ y;
        test.x = x;
        test.y = y;
    }
    public static void main(String[] args) {
        Integer i = 1;
        Integer j = 2;
        Test test = new Test();
        test.swap(i, j);

        System.out.println(i);
        System.out.println(j);

        test.swap(test);

        System.out.println(test.x);
        System.out.println(test.y);
    }
}

In this way, the values of variables can be successfully exchanged: the results are as follows