Java String Constant Pool

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

🧠 Introduction

If you're learning Java, you’ve probably used String values like this:

String name = "Ramesh";

But did you know this string is stored differently than using new String("Ramesh")?

This is because of something called the String Constant Pool.

In this article, we’ll explore:

What the String Constant Pool is
Why Java uses it
How it improves memory usage
Key examples and interview tips

📌 What is the String Constant Pool?

In Java, the String Constant Pool (also called the String Intern Pool) is a special memory area in the Java Heap that stores string literals.

✅ Simply put:

It’s a memory optimization technique that avoids creating duplicate String objects with the same value.

🔍 How It Works

When you create a string like this:

String str1 = "Java";

➡️ Java stores "Java" in the String Pool. If you later write:

String str2 = "Java";

➡️ Java doesn’t create a new object — it simply points str2 to the same "Java" instance in the pool.

But if you do:

String str3 = new String("Java");

➡️ It creates a new object in the heap, even if "Java" already exists in the pool.

✅ Why Does Java Do This?

Strings are immutable, meaning they can’t be changed once created.
Many programs use the same string values repeatedly (like "yes", "no", "OK").
So instead of creating multiple "yes" strings, Java reuses the same one in the pool, saving memory.

🔄 String Pool vs. Heap

Creation Type	Stored In	New Object Created?
`String s = "Java"`	String Constant Pool	❌ No (if already exists)
`String s = new String("Java")`	Java Heap	✅ Yes

💡 Code Example: String Pool in Action

public class StringPoolDemo {
    public static void main(String[] args) {
        String s1 = "Hello";
        String s2 = "Hello";
        String s3 = new String("Hello");

        System.out.println(s1 == s2); // true - same reference from pool
        System.out.println(s1 == s3); // false - different objects
        System.out.println(s1.equals(s3)); // true - same value
    }
}

Output:

true
false
true

🧠 What is `intern()` Method?

Java provides a method called intern() to manually add a string to the pool or get the existing one.

String s4 = new String("World").intern();
String s5 = "World";

System.out.println(s4 == s5); // true

✅ Benefits of String Constant Pool

💾 Memory-efficient: Reuses string objects
⚡ Faster comparisons: Using == for references is faster than .equals()
🧘 Safe to reuse: Since strings are immutable

⚠️ Things to Remember

Only string literals are automatically added to the pool.
new String("value") always creates a new object.
Use intern() if you want to move a runtime string into the pool.
Too many string literals in large applications can still fill up memory — use wisely!

📋 Interview Tip

Q: What's the difference between == and .equals() in String comparison?

== compares references (memory addresses)
.equals() compares actual values

So in String Pool:

String a = "Java";
String b = "Java";
System.out.println(a == b); // true

But with new String:

String x = new String("Java");
System.out.println(a == x); // false

✅ Summary

Concept	Explanation
String Pool	Special memory area to store string literals
Immutable Strings	Safe to share references
`"Java"` vs `new String("Java")`	First reuses, second creates a new object
`intern()`	Manually adds a string to the pool

Final Thoughts

The String Constant Pool is a powerful concept that improves both performance and memory usage in Java applications. By understanding how it works, you can write better, more efficient Java code.

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Spring Boot + RabbitMQ Course - The Practical Guide

Java Guides

Search This Blog