Java Strings

A String in Java is an object used to store a sequence of characters enclosed in double quotes. It uses UTF-16 encoding and provides methods for handling text data.

• Each character in a string is stored using 16-bit Unicode (UTF-16) encoding.
• Strings are immutable, meaning their value cannot be changed after creation.
• Java provides a rich API for manipulation, comparison, and concatenation of strings.

Example:

String name = "Geeks";
String num = "1234";

Note: The diagram conceptually shows the sequence of characters in a string, not its actual JVM memory layout. Since Java 9, Java uses Compact Strings (byte[] with a coder field), and the JVM does not expose object memory addresses.

public class Geeks {

    // Main Function
    public static void main(String args[])
    {

        // creating Java string using a new keyword
        String str = new String("Geeks");

        System.out.println(str);
    }
}

Geeks

Explanation: The program creates a String object containing "Geeks" using the new keyword and prints it using System.out.println().

Ways Of Creating a Java String

There are two ways to create a string in Java: 

1. String literal (Static Memory)

A string literal is created by assigning a sequence of characters directly to a String variable using double quotes. Java stores string literals in the String Constant Pool, allowing identical string values to share the same object.

Example:

String str = “GeeksforGeeks”;

2. Using new keyword (Heap Memory)

Using the new keyword creates a new object in heap memory, even if the same string already exists in the pool.

• One object is created in the heap memory
• The string literal is stored in the string pool (if not already present)
• The reference variable points to the heap object, not the pool

Example:

String str = new String (“GeeksforGeeks”);

Interfaces and Classes in Strings

CharSequence Interface

The CharSequence interface represents a sequence of characters in Java. It provides common methods such as length(), charAt(), subSequence(), and toString() for working with character sequences.

Common classes that implement CharSequence include:

• String: An immutable class whose contents cannot be modified after creation; any modification results in a new String object.
• StringBuffer: A mutable and thread-safe class used for string manipulation, particularly when synchronization is required.
• StringBuilder: A mutable and non-thread-safe class commonly used for efficient string manipulation when synchronization is not required.

Immutable String

In Java, string objects are immutable. Immutable simply means unmodifiable or unchangeable. Once a string object is created its data or state can't be changed but a new string object is created.

public class GFG{
    
    public static void main(String[] args) {

        String str = "Hello";

        str.concat(" World");

        System.out.println(str);
    }
}

Hello

Explanation: In the above example, the String.concat() does not modify the original String object. When str.concat(" World") is executed:

• A new String object "Hello World" is created.
• The original String "Hello" remains unchanged.
• Since the new object is not assigned to any variable, it is discarded.

How Strings are Stored in Java Memory

String literal

When a String is created using a string literal, the corresponding String object is stored in the String Pool, which is part of the heap. The reference variable refers to that pooled String object.

Example 1: Using String literals to assigning char sequence value.

String str1 = "Hello";

Example 2: When we initialize the same char sequence using string literals.

String str1 = "Hello";
String str2 = "Hello";

Using new Keyword

Strings can also be created using the new keyword, which allocates a new object in heap memory. However, the string literal inside it is still stored in the String Constant Pool (if not already present).

Example 1: Using new keyword to assign a char sequence to a String object.

String str1 = new String("John"); String str2 = new String("Deo");

The intern() method returns the canonical String reference from the String Pool. If an equal String is not already present in the pool, it is added to the pool; otherwise, the existing pooled String reference is returned.

Example 2: Using .intern() to add a string object in string constant pool.

// this will add the string to string constant pool.
String internedString = demoString.intern();

When a String is created using a string literal, the corresponding String object is stored in the String Pool. When new String() is used, a separate String object is created on the heap, while the string literal passed to the constructor is stored in the String Pool if it is not already present. The intern() method returns the corresponding canonical String reference from the String Pool.

String Pool

The String Pool is a special area in heap memory where Java stores string literals. It helps save memory by reusing existing string objects when the same literal is used multiple times.

For example:

String s1 = "Geeks";
String s2 = "Geeks";

Here, Java can reuse the same "Geeks" string from the String Pool for both references.

For detailed information about String Pool memory management and its behavior across Java versions, refer to the dedicated String Pool Java article.

Let us have a look at the concept with a Java program and visualize the actual JVM memory structure: 

class Geeks
 {
    public static void main(String args[])
    {
        
      	// Declaring Strings using String literals
        String s1 = "TAT";
        String s2 = "TAT";

        // Declaring Strings using new keyword
        String s3 = new String("TAT");
        String s4 = new String("TAT");

        // Printing all the Strings
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);
    }
 }

TAT
TAT
TAT
TAT

Explanation: s1 and s2 use the same String literal, so they can refer to the same String Pool object. s3 and s4 are created using new, so each represents a separate String object on the heap. All four variables contain the same text, "TAT".

Note: All objects in Java are stored in a heap. The reference variable is to the object stored in the stack area or they can be contained in other objects which puts them in the heap area also.