Java String Pool | Java Development Journal

1. Introduction

In this lesson of Java course, we will look at the Java String pool. In Java, strings are a fundamental data type used to represent text-based data. The String class is immutable, so once a string is created, it cannot be changed. This immutability feature makes strings thread-safe and provides an easy way to work with text-based data.

One important aspect of string creation in Java is the concept of the string pool and the new keyword. In this article, we’ll explore these concepts and how they affect string creation and memory management in Java.

2. Java String Pool

The Java string pool is a cache-like structure that stores a collection of unique string literals. When we create a string using a string literal, Java first checks the string pool to see if an equivalent string already exists. If it does, it returns a reference to the existing string instead of creating a new one. This feature helps to reduce memory usage and improve performance in Java applications. Let’s look at an example to better understand the Java String pool concept:

String str1 = "Hello World";
String str2 = "Hello World";
String str3 = new String("Hello World");

System.out.println(str1 == str2); // true
System.out.println(str1 == str3); // false

In this example, str1 and str2 are created using string literals. Since the string pool checks for equivalent strings, both variables reference the same string in memory. Thus, the output of str1 == str2 is true.

In contrast, str3 is created using the new keyword, which creates a new string object in memory regardless of whether it is equivalent to an existing string in the pool. Thus, the output of str1 == str3 is false.

2.1. Memory Allocation in String Pool

In Java, String literals are stored in the String Pool, which is a special area of the heap memory. When a String literal is declared, Java checks whether the String is already in the String Pool. If it is, then Java returns a reference to that String. If it is not, then it creates a new String object and adds it to the String Pool.

Java string pool helps if multiple String literals with the same value are used in the code, they will refer to the same object in the String Pool, which saves memory and improves performance.

The String Pool is managed by the JVM, which automatically adds Strings to the Pool when they are created. Strings can also be added to the String Pool explicitly by calling the intern() method on a String object. This method returns a reference to the String object in the String Pool, or adds the String to the String Pool if it is not already there.

3. The `new` Keyword

The new keyword is used to create a new instance of a class in Java. When used with the String class, it creates a new string object in memory, even if an equivalent string already exists in the string pool. Let’s look at an example:

String str1 = "Hello World";
String str2 = new String("Hello World");

System.out.println(str1 == str2); // false

In this example, str1 is created using a string literal, and str2 is created using the new keyword. Since str2 creates a new string object in memory, the output of str1 == str2 is false.

4. Difference between String Pool and creating using new keyword

String Pool	Creating using new keyword
String literals are automatically added to the String Pool.	A new String object is created on the heap memory, regardless of whether the String already exists in the String Pool or not.
Multiple String literals with the same value refer to the same object in the String Pool.	Multiple String objects with the same value can be created on the heap memory.
Strings in the String Pool are not garbage collected until the JVM shuts down.	String objects created using the new keyword are subject to garbage collection when they are no longer referenced.
Accessing Strings in the String Pool is faster than accessing Strings created using the new keyword, as the JVM can reuse existing objects.	Creating Strings using the new keyword can be slower, as the JVM has to allocate new memory for each String object.
Adding large or frequently changing Strings to the String Pool can cause memory leaks.	Garbage collection can remove unused String objects created using the new keyword, which can help prevent memory leaks.

5. When to use Java String Pool

The String Pool is useful when you need to use multiple String literals with the same value in your code. By using the String Pool, you can ensure that these Strings refer to the same object in memory, which saves memory and improves performance.

Remember, Java String pool can also cause memory leaks if you are not careful. You should use this feature carefully.

Since Strings in the String Pool are not garbage collected until the JVM shuts down, adding too many Strings to the Pool can cause your application to run out of memory.

use the String Pool only when you need to use multiple String literals with the same value.
Avoid adding large or frequently changing Strings to the Pool. If you need to create Strings dynamically.
Use the StringBuilder or StringBuffer classes instead of concatenating Strings using the + operator, which can create numerous temporary String objects

Summary

In Java, the string pool and the new keyword play an important role in string creation and memory management. By using string literals, we can take advantage of the string pool and reduce memory usage in our applications. However, if we need to create a new string object, we should use the new keyword to ensure that a new instance of the String class is created. By understanding these concepts, we can write more efficient and effective Java code that meets the needs.

As always, the source code of our Java course is available on the GitHub repository.