Difference between Java heap and stack

First, let's talk about a seemingly unrelated question: How do you operate a Java object?

You may have heard that everything in Java is an object. Although we treat everything as an object, direct operations are not the object itself, but the object reference, that is, reference.

The following is a good analogy:

You might imagine a television (the object) and a remote control (the reference ). as long as you're re holding this reference, you have a connection to the television, but when someone says, "change the channel" or "lower the volume," What you're re manipulating
Is the reference, which in turn modifies the object. If you want to move around the room and still control the television, you take the remote/reference with you, not the television.

Also, the remote control can stand on its own, with no television. that is, just because you have a reference doesn't mean there's necessarily an object connected to it. so if you want to hold a word or sentence, you create a string reference:
String S;
But here you 've created only the reference, not an object.

String S = "ASDF"; in this case, an instance is available and the memory is allocated.

Now let's go to the subject.

Both stack and heap are places where Java is used to store data in Ram. Unlike C ++, Java automatically manages stacks and stacks,ProgramYou cannot directly set stacks or stacks.

 

The Java heap is a runtime data zone,Class objects to allocate space from them. These objects are created using commands such as new, newarray, anewarray, and multianewarray.CodeTo explicitly release. The heap is responsible for garbage collection. The advantage of the heap is that the memory size can be dynamically allocated, and the lifetime does not have to be told in advance because the heap dynamically allocates memory at runtime, the Java Garbage Collector automatically collects the unused data. However, the slow access speed is due to the need to dynamically allocate memory during runtime.

At the same time, the class itself, that is, the instance of the class corresponding to each class, is also stored in the heap.

 

The advantage of stack is that the access speed is faster than that of stack, second only to register, and stack data can be shared. However, the disadvantage is that the data size and lifetime in the stack must be fixed, and there is a lack of flexibility. The stack mainly stores some basic types of variables, that is, the so-called primitive variables (INT, short, long, byte, float, double, Boolean, char) and object references.

The objects generated with new are stored in the stack, and the objects are stored in the heap.

Because the stack efficiency is higher than the stack efficiency, for some small variables, such as int and Boolean, the efficiency in the stack is relatively low, so it is directly placed in the stack. Compared with objects instantiated with the New Keyword, the variables reference and objects themselves are stored in the stack.

 

Because of this, the stack has a very important feature, that is, the data in the stack can be shared. Suppose we define both:

Int A = 3;

Int B = 3;

The compiler first processes int A = 3. First, it creates a reference with the variable A in the stack, and then finds whether the value 3 in the stack exists. If no value is found, store 3 and point A to 3. Then process int B = 3. After the referenced variable of B is created, B is directed to 3 because there is already 3 in the stack. In this way, both A and B point to 3 at the same time.

 

At this time, if A is set to 4 again, the compiler will re-search whether there are 4 values in the stack. If not, it will store 4 and make a point to 4; if yes, direct a to this address. Therefore, changing the value of A does not affect the value of B.

 

Note that the sharing of data is different from the sharing of two objects pointing to one object at the same time, because the modification of a does not affect B, which is completed by the compiler, it facilitates space saving. A variable referenced by an object modifies the internal state of the object, which affects the variable referenced by another object.

 

String is a special packaging data. Available:

String STR = new string ("ABC ");

String STR = "ABC ";

The first method is to use new () to create an object, which is stored in the heap. Each call creates a new object.

The second is to first create a string class object in the stack to reference the variable STR, and then find whether the stack contains "ABC". If not, store "ABC" into the stack and point STR to "ABC". If "ABC" already exists, direct STR to "ABC ".

 

Use the equals () method to compare the values in a class. Use the = method to test whether the references of the two classes point to the same object. The example below illustrates the above theory.

String str1 = "ABC ";

String str2 = "ABC ";

System. Out. println (str1 = str2); // true

It can be seen that str1 and str2 point to the same object.

 

String str1 = new string ("ABC ");

String str2 = new string ("ABC ");

System. Out. println (str1 = str2); // false

The new method is used to generate different objects. Each time one is generated.

 

Therefore, the second method is used to create multiple "ABC" strings, and only one object exists in the memory. this method is advantageous and saves memory space. at the same time, it can improve the program running speed to a certain extent, because the JVM will automatically decide whether to create a new object based on the actual situation of the data in the stack. For the code of string STR = new string ("ABC");, a new object is created in the heap, regardless of whether the string value is equal, whether it is necessary to create a new object, this increases the burden on the program.

 

On the other hand, NOTE: When we define classes using formats such as string STR = "ABC";, we always take it for granted that the STR object of the string class is created. Worry trap! The object may not be created! Instead, it may only point to a previously created object. Only by using the new () method can a new object be created every time.

Immutable properties of the string class:

String S = "ABC ";

S = "123 ";

This is okay because the "ABC" in the memory cannot be modified, but s can point to another string "123 ". That is to say, the so-called string variable means that the content pointed to by the string itself cannot be changed.

In this way, when the value of a string is often changed, a new string is created every time it changes, and a large number of strings are created in the memory. Therefore, we should consider using the stringbuffer class to improve program efficiency.