String Pool in Java

Last Updated on March 31, 2023 by Prepbytes

The String Pool is a feature in Java that saves memory and improves performance by storing unique String objects in a pool and reusing them. In this article, we will explore the concept of the String Pool, how it works, and its advantages and disadvantages in Java applications.

What is String Pool in Java?

In Java, the string pool is a pool of unique string objects stored in the heap memory. When a string is created, Java first checks whether it already exists in the pool. If it does, then the existing object is returned. If this is not the case, a new object is generated and started adding to the pool. This optimization saves memory and improves performance in string-intensive programs.

Memory Allocation of String Pool in Java

The String Pool in Java is a part of the JVM’s heap memory, which is allocated when the JVM starts up. The size of the String Pool itself depends on the number and size of the string literals used in the application. When a string literal is encountered in the code, the JVM checks if it already exists in the String Pool. If it does, a reference to the existing object is returned. If it doesn’t, a new String object is created and added to the String Pool.

Ways to Create Strings in Java

There are several ways to create String objects in Java, including:

Using String literals:

String literals are created by enclosing the string in double quotes.

Example for using string literals:

public class Main {
    public static void main(String[] args) {
        String str1 = "Hello World"; 
        String str2 = "Hello World"; 
        
        System.out.println(str1 == str2); 
        System.out.println(str1.equals(str2)); 
        
        String str3 = new String("Hello World"); 
        String str4 = new String("Hello World"); 
        
        System.out.println(str3 == str4); 
        System.out.println(str3.equals(str4)); 
    }
}

Explanation of string literals:
In Java, the new keyword creates a new object of a class. When creating a String object using new, it creates a new object in the heap memory instead of the string pool. This means that a new String("string") will always create a new object while using a string literal like "string" will first check if the string exists in the string pool, and reuse it if it does.

Using the new keyword:

String objects can be created using the new keyword.

Example of using the new keyword:

public class Main {
    public static void main(String[] args) {
        String str1 = "Hello World";
        String str2 = new String("Hello World"); 
        System.out.println(str1 == str2); 
        System.out.println(str1.equals(str2));
        Integer num1 = 10; 
        Integer num2 = new Integer(10);
        System.out.println(num1 == num2); 
        System.out.println(num1.equals(num2));
    }
}

Explanation of new keyword:
In Java, the new keyword creates a new object of a class. When creating a String object using new, it creates a new object in the heap memory instead of the string pool. This means that new String("string") will always create a new object, while using a string literal like "string" will first check if the string exists in the string pool, and reuse it if it does.

Using Java string.intern() Method:

The String.intern() method in Java returns a string object, which is guaranteed to be unique.

Example of using the java string.intern() Method:

public class Main {
    public static void main(String[] args) {
        String str1 = "Hello World"; 
        String str2 = new String("Hello World");
        System.out.println(str1 == str2); 
        String str3 = str2.intern(); 
        System.out.println(str1 == str3); 
    }
}

Explanation of intern() Method:
The intern() method of the String class in Java returns a string object, which is guaranteed to be from the string pool, a storage area in memory where the JVM stores all string literals. If a string is already present in the string pool, the intern() method returns a reference to that object. Otherwise, it adds the string to the string pool and returns a reference to the newly added object.

Flowchart of String Pool in Java

Here, is the flowchart of the string pool in Java:

Explanation of flowchart:
When the Java Virtual Machine (JVM) encounters a string literal in the code, it first checks the string pool to see if a string with the same value already exists in the pool. If a string with the same value exists in the pool, the JVM returns a reference to that string object in the pool. If a string with the same value does not exist in the pool, the JVM creates a new string object in the pool with the value of the string literal. The JVM then returns a reference to the new string object in the pool. Subsequent references to the same string literal in the code will return a reference to the same string object in the pool.

Example of String Pool in Java

public class Main {  
public static void main(String[] args){  
String str1 = "Hello world";
String str2 = "Hello world";
String str3 = new String("Hello world");
System.out.println(str1 == str2); 
System.out.println(str1 == str3); 
System.out.println(str1.equals(str3)); 
}  
} 

Explanation of example for String Pool in Java:
In the string pool example, the first two string objects str1 and str2 are created using string literals, which are automatically added to the String Pool. The third string object str3 is created using the new operator, which creates a new string object outside the pool.

Advantages of String Pool in Java

Some of the advantages of String pool in Java:

• Memory efficient.
• Faster performance.
• Simplifies string equality comparisons.
• Supports immutable strings.
• Allows string interning.

Disadvantages of String Pool in Java

Some of the disadvantages of String pool in Java:

• Potential for memory leaks.
• Limited control over object lifetime.
• Can cause unexpected behavior with mutable strings.
• Strings may remain in memory even if no longer needed.
• String interning can cause unexpected results if not used carefully.

Conclusion
In conclusion, the String Pool in Java has multiple benefits such as memory efficiency, performance improvement, and simplified string comparisons. However, it also has some potential drawbacks, such as limited control over an object’s lifetime and the potential for memory leaks. Understanding the use cases and limitations of the String Pool is important for Java developers to ensure optimal application performance and avoid unexpected behavior.

Frequently Asked Questions(FAQs)

1. What is the purpose of the string pool in Java?
The purpose of the string pool in java is to optimize memory usage by reusing common string literals, rather than creating a new object each time the same literal appears in the code.

2. How do string literals get added to the string pool in java?
When a string literal appears in the code, the Java Virtual Machine (JVM) checks the string pool to see if a string with the same value already exists. If it does not exist, the JVM adds a new string object to the pool with the value of the literal.

3. Can you add strings to the string pool in java manually?
No, you cannot add strings to the string pool in java manually. The JVM manages the string pool automatically.

4. Are all string objects stored in the string pool in java?
No, only string literals are stored in the string pool in java. Strings created using the new keyword or other constructors are not stored in the pool.

5. Can string objects be removed from the string pool in java?
No, once a string object is added to the string pool in java, it remains there until the program terminates or the JVM is restarted.

6. Is the string pool in javathread-safe?
es, the string pool in java is thread-safe. Multiple threads can safely access and share the same string objects in the pool.