The String class in Java is used to represent and work with sequences of characters. It is part of the java.lang package and provides various methods for creating, comparing, searching, and manipulating strings. String objects are immutable, meaning their values cannot be changed after creation.

• String literals can be stored and reused through the String Pool.
• Immutability makes String objects safe to share and use across multiple parts of a program.
• Strings can be created using string literals or the new keyword.

Key Features of the String Class

1. Immutable

Immutable means that once a String object is created, its value cannot be changed.

Example:

public class Main {
    public static void main(String[] args) {
        String text = "hello";
        text.charAt(0) = 'H';  // compile-time error
    }
}

Explanation: The line text.charAt(0) = 'H'; causes a compile-time error because charAt(0) returns a read-only char, not a variable. String is immutable in Java, you cannot modify its characters directly.

2. Thread-Safe

String objects in Java are considered thread-safe because they are immutable. Once a String object is created, its value cannot be modified, so multiple threads can safely read and share the same String object without changing its contents.

• Multiple threads can access the same String object safely for read operations.
• No synchronization is required to protect the String object's value from modification.
• Operations that appear to modify a String actually create a new String object instead of changing the existing one.

3. Supports Various Utility Methods

String is a predefined final class in Java present in java.lang package. It provides various methods to create, manipulate, and compare strings, like length(), charAt(), concat(), equals(), etc.

import java.io.*;

class GFG {
    public static void main (String[] args) {
        String str = "hello geeks";
        System.out.println("Length of String-> "+str.length()); 
        System.out.println("Changed String ->"+str.toUpperCase());
    }
}

Length of String-> 11
Changed String ->HELLO GEEKS

4. Implements Interfaces

The String class implements several interfaces that provide features such as character-sequence handling, comparison, serialization, and constant description.

• CharSequence: Provides methods for accessing a sequence of characters, such as charAt() and length().
• Comparable<String>: Enables lexicographical comparison of strings using compareTo().
• Serializable: Allows String objects to be serialized.
• Modern Java versions also support additional interfaces related to constant descriptions.

String Constructors in Java

In Java, String constructors are used to create new String objects from different sources like character arrays, byte arrays, or another string. Although strings in Java are usually created using string literals, the String class also provides constructors for more control.

Let us check these constructors using a example demonstrating the use of them.

public class Geeks {
    public static void main(String[] args) {
        
        // Constructor 1: Creating string using new keyword
        String str1 = new String("Hello Java");
        System.out.println("String using new keyword: " + str1);

        // Constructor 2: Creating string from character array
        char[] charArray = { 'J', 'A', 'V', 'A' };
        String str2 = new String(charArray);
        System.out.println("String from char array: " + str2);

        // Constructor 3: Creating string from byte array
        byte[] byteArray = { 72, 101, 108, 108, 111 };
        String str3 = new String(byteArray);
        System.out.println("String from byte array: " + str3);
    }
}

String using new keyword: Hello Java
String from char array: JAVA
String from byte array: Hello

String Constructors Table