Classic string STR = new string ("ABC") Memory Allocation Problems

From: http://blog.csdn.net/ycwload/article/details/2650059

Today, I am looking for some knowledge related to storage management. I haven't found any perfect information on the Internet for a long time (I can't find it in 30%, I downloaded a PDF teaching book from my former university. After reading it for a whole day, I understood some of the knowledge in storage management. Once upon a time, I wrote some useless small topics in the university. I felt that the things taught in the university were not practical, and the theory was too serious. I always thought that people who taught with theory always spoke about it, people who do things. Therefore, in college, I can only say that I have to take exams, and I have not learned much about many things. It was not until today that I finally understood that books were less hated when they were used. Many things, the teacher taught us in college, don't care, don't worry, now only to understand that they have lost a fortune.

When the code is written to a certain amount, there will be no Java/C # points; when the technology is deep, there will be no software/hardware points. All is a single goal: efficiency. This article is an article that I occasionally find when searching for storage management. It seems very good and classic, because I have been writing Java for a long time, it is not clear the specific differences between the two sentences. Copy it. You can check it out. Although the theft is not advisable, I learned it as my own. Who would say I stole it? Do something that helps others. Others are happy and they are happy.

 

What are the differences between the following two sentences in Java?
String str1 = "ABC ";
String str2 = new string ("ABC ");

Java divides memory into two types: stack memory and stack memory.
Variables of some basic types defined in the function and referenced variables of the object are allocated in the function stack memory.
When a variable is defined in a code block, Java allocates memory space for the variable in the stack. When the scope of the variable is exceeded, java will automatically release the memory space allocated for the variable, and the memory space can be used for another use immediately.
Heap memory is used to store objects and arrays created by new.
The memory allocated in the heap is managed by the Java Virtual Machine's automatic garbage collector.
After an array or object is generated in the heap, you can define a special variable in the stack so that the value of this variable in the stack is equal to the first address of the array or object in the heap memory, the variable in the stack becomes the referenced variable of the array or object.
The referenced variable is equivalent to an array or an object name. Later, you can use the referenced variable in the stack in the program to access the array or object in the heap.

Specifically:
Both stacks and stacks are places where Java is used to store data in Ram. Unlike C ++, Java automatically manages stacks and stacks, and programmers cannot directly set stacks or stacks.
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 types of 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.

(

At this point, the author has said that equals () and = in Java are two different concepts. The first one is to determine whether the values are equal, the latter is the identification of whether the referenced address is equal.

String str1 = "ABC ";

String str2 = new string ("ABC ");

Let's take a look:

Str1.equals (str2) Value

Str1 = str2 Value

)

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. 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.

 

Exercise questions:
The following code generates several string objects

String A = "ABC"; string B = "ABC"; string c = new string ("ABC"); string d = C. intern (); string a = "ABC"; // allocate space string B = "ABC"; // do not allocate space string c = new string ("ABC "); // allocate space string d = C. intern (); // This sentence is the key !!

If this is the case

C = D? The result is false;
Because the reference variable C points to the heap memory address, but intern (); opens up a piece of memory in the stack.

For this question:
C. Intern (); During execution, an object "ABC" is found in the stack memory, so direct the pointer to "ABC"
In this case, the result of a = D, B = D is true;

So the answer to this article is 2.

 

Classic string STR = new string ("ABC") Memory Allocation Problems