In Java, strings are stored in the memory as objects of the class String.
When memory is allocated for any Java program, JVM (Java virtual machine) divides allocated memory into two parts. One part is Stack and the other part is Heap. In Heap memory, java allocates some memory, especially for literals that memory is called the String constant pool(SCP). SCP is the predefined area inside the Heap. String pool helps in saving a lot of space for Java Runtime. String class uses SCP to store unique string literals.
In Stack memory, variables or variable references or references to the objects are stored.
In Heap memory, all the objects that are dynamically allocated are stored. To allocate memory to an object we use a new keyword.
There are two ways of creating string objects.
- String literal
String str1 = “MyString”;
Whenever we create a string literal, JVM first checks if the string literal already exists in the string constant pool. If not available, it will create a new string literal in SCP.
In the picture above, str1 points to “MyString” in SCP. Following are the ways newly created string literals are handled.
- By using a new keyword
String str2 = new String(“MyString”); //Instantiating the string class using a new keyword
When a string object is created using a new keyword, it will create two objects. One in SCP another in Heap and the reference variable is stored in the stack.
We have already created the literal “MyString” by using
String str1 = “MyString”;
As we cannot have duplicates in SCP, So JVM will not create one more object in SCP but will return the existing reference to the variable str3 in the stack and it will create one object in Heap. Str3 will point to the object “MyString” in the Heap but not in SCP.
Following are the different cases of how memory is allocated for string objects.
Case 1: How the string objects defined above are stored in memory.
public class stringsStorageConcept
{
public static void main(String[] args)
{
String str1 = “MyString”;
String str2 = new String(“MyString”);
System.out.println(str1 == str2); //Output:False
System.out.println(str1.equals(str2)); //Output:True
}
}
When we compare str1 and str2 using the “==” operator it returns false. As we know “==” operator compares their physical addresses. Here in our example str1 is pointing to the object in SCP and str2 is pointing to the object in the Heap. So it returns false.
But in the case of str1.equals(str2), as we know “equals” function checks the individual characters both str1 and str3 have the same value stored it returns true.
Case 2: Another string literal
String str3 = “MyString”;
Both str1 and str3 will point to the same string literal in SCP.
public class stringsStorageConcept
{
public static void main(String[] args)
{
String str1 = “MyString”;
String str3 = “MyString”;
System.out.println(str1 == str2); //Output:True
System.out.println(str1.equals(str2)); //Output:True
}
}
s1 == s3 returns true, as “==” operator compares their physical addresses but not the content.
s1.equals(s3) returns true, and the “equals“ function checks the individual characters in both reference variables.
Case 3: Another string object is created using a new keyword
String str4 = new String(“NewString”);
In this case, JVM will check for this string in SCP it cannot find the string object with the value “NewString”, so it will create two objects one in SCP and another in Heap, the reference variable str4 will be stored in the stack. Str4 will have the reference to the object in the Heap.
Case 4: Another string literal is created.
String str5 = “NewString”;
In this case, JVM will check in SCP if this literal is already available or not, here “NewString” is already present in SCP so JVM will not create a duplicate in SCP instead it returns the reference to the variable str5.
Case 5: Assigning one string to another string
String str4 = new String(“NewString”);
String str6 = str4; //Assigning
Here str6 and str4 will point to the same object in Heap and will not erase the value in str4.
public class stringsStorageConcept
{
public static void main(String[] args)
{
String str4 = new String(“NewString”);
String str6 = str4;
System.out.println(str4 == str6); //Output:true
}
}
JVM will give the reference of the “NewString” in the heap to the variable str6. That’s the reason str4 == str6 returns true.
In conclusion, creating string objects using string literal and by ‘new’ operator has its pros and cons.
By using string literals, we can make memory more efficient by not creating duplicates. JVM creates one unique object and the string stays in the SCP forever. The downside of this is that the string pool has a fixed size and it will get full at some time.
But by using a new keyword it creates two objects, one in SCP and the other in Heap. In a Heap, if we don’t need the object it will be erased by a garbage collector to make space. But the downside of this is that with a ‘new’ operator JVM will always have to create a new object and it is an overload for JVM.
Top comments (0)