String Constant Pool

What is a String Constant Pool?

One of the main goals of Java programming language is to minimize the redundancy and memory waste/overuse caused by storing String objects with duplicate values on the heap memory and this is why JVM sets aside a special area on the heap called String Constant Pool.

Note : Before we know more about String constant pool, we need to remember that a String object can be created with or without using the new keyword.

Important points to remember

String objects created without the use of new keyword are stored in the String Constant Pool part of the heap.

String objects created using new keyword are stored in the normal memory part on the heap.

How String Constant Pool saves memory?

Now let's understand how String Constant Pool saves memory by a short code :-
```
String s1 = "Hello";             // Statement 1 
String s2 = "Hello";             // Statement 2 
String s3 = new String("Hello"); // Statement 3
```
After executing these three statements, String constant pool part on heap(a special area on the heap) and the other normal part of heap are represented by Figure 1.
- After executing statement 1, String object with value Hello is stored in String Constant Pool part on the heap because this object is constructed without using the new keyword.
- Statement 2 asks for the creation of another String object with the same value Hello without using the new keyword. Before allocating this object on String Constant Pool part of heap memory, JVM checks if there is already a String object with the value Hello present in String Constant Pool on the heap and, it finds a String object with a similar value Hello being referred by a reference variable s1 already.
- In order to save the memory from storing a String object with a duplicate value, JVM assigns the reference of the existing String object with value Hello to reference variable s2 as well, thus saving heap memory. Now reference variables s1, s2 point to same String object with value Hello(Figure 1).
- After executing statement 3, String object with a value Hello is created in a normal non-pool part of Heap memory because this object is created using the new keyword.
Advertisement

String constant pool example

Here in the upcoming program, we have created three String objects and we are using == relational operator, which checks for equality of references i.e. if two references point to a similar object, to show String Constant Pool saves memory when storing duplicate String objects.
```
// String Constant Pool Example

class A
{
public static void main(String... ar)
{
String s1 = "Hello";  //creating a String object in String Constant Pool heap memory
String s2 = "Hello";  //creating a String object in String Constant Pool with duplicate value

String s3 = new String("Hello"); //creating String object in the normal heap memory.
String s4 = new String("Hello"); //creating String object in the normal heap memory.

System.out.println("Do s1 and s2 point to a same String object ? "+ (s1==s2));

System.out.println("Do s1 and s3 point to a same String object ? "+ (s1==s3));

System.out.println("Do s3 and s4 point to a same String object ? "+ (s3==s4));
}
}
```
Output is :
```
Do s1 and s2 point to a same String object ? true
Do s1 and s3 point to a same String object ? false
Do s3 and s4 point to a same String object ? false
```
Program Analysis
- To avoid storing duplicate String objects on String Constant Pool heap memory, reference variables s1 and s2 refer to the same String object with value Hello on String constant pool memory on the Heap, whereas, the reference variable s3 and s4 point to objects created in a normal memory on Heap, as these objects were created using the new keyword.
- The operator == returns true on checking check if references s1 and s2 point to a similar object, which proves that both references, s1 and s2 are pointing to the same object on String constant pools and thus saving memory.
- But, the operator == returns false when reference s1 was compared with s3, because, s1 points to a String object in String Constant Pool memory on the Heap while s3 points to a String object in normal Heap.
- Finally, the operator == returns false when reference s3 was compared with s4. Although both reference variable s3 and s4 point to the String objects with the same value Hello but as these objects are creating with the new keyword, hence, these objects are stored in normal heap memory where the String objects with duplicate values can be stored.
Please share this article -

< Prev

Next >

< What is String?

Immutable String >

Advertisement