Difference between heap and stack in java

Difference between heap and stack in java

The Java heap is a runtime data zone and class (the object allocates space from it. These objects are created using commands such as new, newarray, anewarray, and multianewarray. They do not need program code to be explicitly released. 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.

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 class variables (, int, short, long, byte, float, double, boolean, char) and object handles.

A very important feature of stacks is that data in stacks 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 first method is used to create multiple "abc" strings. 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.
Because of the immutable property of the String class, when the String variable needs to change its value frequently, you should consider using the StringBuffer class to improve program efficiency.

Stack and stack in java are different !!!!

First, from the perspective of software design, stack represents the processing logic, while stack represents the data. This separation makes the processing logic clearer. Divide and conquer. This idea of isolation and modularization is embodied in all aspects of software design.

Second, the separation of heap and stack allows the heap content to be shared by multiple stacks (it can also be understood as multiple threads accessing the same object ). There are a lot of benefits for such sharing. On the one hand, this sharing provides an effective way of data interaction (such as shared memory), on the other hand, shared constants and caches in the heap can be accessed by all stacks, saving space.

Third, the stack needs to divide the address segment because of its runtime needs, such as saving the context of the system running. Since the stack can only grow up, it will limit the stack's storage capacity. The heap is different. Objects in the heap can dynamically grow as needed. Therefore, the stack and heap splitting makes dynamic growth possible. In the corresponding stack, you only need to record an address in the heap.

Fourth, object-oriented is the perfect combination of stack and stack. In fact, there is no difference between an object-oriented program and a previously structured program in execution. However, the introduction of object-oriented makes the Way of Thinking About Problems change, and it is closer to thinking about natural ways. When we split the object, you will find that the object's attribute is actually data, stored in the heap; and the object's behavior (method) is the running logic, placed in the stack. When writing objects, we actually write the data structure and the data processing logic. I have to admit that the object-oriented design is really beautiful.

What should I do if I ask the difference between stack and stack in java during the interview?

The Java heap is a runtime data zone and class (the object allocates space from it. These objects are created using commands such as new, newarray, anewarray, and multianewarray. They do not need program code to be explicitly released. 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.

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 class variables (, int, short, long, byte, float, double, boolean, char) and object handles.

A very important feature of stacks is that data in stacks 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 first method is used to create multiple "abc" strings. Only one object exists in the memory. this method is advantageous and saves memory space. at the same time, it can improve the running speed of the program to a certain extent, because the JVM will automatically decide whether there is ...... remaining full text>