Why String is Immutable in Java with Example

In this post, we are going to learn why the String class is immutable in Java and what that means for developers. We will also look at a simple example to understand this concept better. The question of why String is immutable often gets asked in Java interviews, so knowing about the immutability of strings in detail is important for both Job seekers and experienced Java developers. Let's dive in to understand why Strings in Java are immutable.

What Does Immutable Mean?

Before diving into why String is immutable, let's first understand what immutability means. In Java, when we say an object is immutable, it means that once the object is created, its state cannot be changed. Any modification to that object results in a new object being created rather than altering the existing one.

Why is String Immutable in Java?

There are several reasons why String is designed to be immutable in Java, and Here we are going to discuss some of the key reasons:

1. Security

One of the main reasons for making String immutable is security. Strings are widely used for storing sensitive information like passwords, usernames, and connection URLs. If String were mutable, it would be easy for a malicious program to modify the content of a string object and potentially expose sensitive data. By making String immutable, Java ensures that once a string is created, its content cannot be changed, making it more secure.

2. Caching and Performance

Another reason for String immutability is performance. Since strings are immutable, they can be safely shared between different parts of the program without worrying about them being changed. Java takes advantage of this by using a concept called "string pool." When you create a new string literal Java first checks if the string is already present in the pool or not. If it is present, then the existing string is returned instead of creating a new one. This reduces memory usage and improves performance.

3. Thread-Safety

In a multi-threaded environment, where multiple threads are running simultaneously, immutability is crucial. Since String objects are immutable, they can be safely shared between threads without the need for synchronization. This avoids potential issues like race conditions and makes the code simpler and more reliable.

4. Class Loading

Strings are heavily used in class loading. For Example, the name of a class is passed as a string. If strings were mutable, it could lead to security risks, where the class name might be changed during the loading process. By making String immutable, Java ensures that the class name remains consistent and secure throughout the loading process.

Example:

Let's take a simple example to understand how String immutability works in practice:

public class ImmutableStringExample {
    public static void main(String[] args) {
        // Create a string
        String originalString = "Hello";

        // Try to change the string
        String modifiedString = originalString.concat(" World");

        // Print both strings
        System.out.println("Original String: " + originalString);
        System.out.println("Modified String: " + modifiedString);
    }
}

In the above example, we can clearly see that we have created a string originalString with value "Hello" and then we try to modify that string by concatenating " World" to it. But instead of modifying or changing the original string Java creates a new String object modifiedStriing which contains the concatenated results. The original string remains unchanged.

When we run the program it will show the following output:

Original String: Hello
Modified String: Hello World

So in short String is immutable in Java to enhance the security, performance, thread-safety, and reliability of the application. By making strings unchangeable, Java ensures that sensitive information remains secure, which helps us to use memory efficiently using string pooling and share strings safely across the multiple threads without getting any synchronization issues. Immutability also helps to maintain the consistency of class names during the class loading.

Menu

Sep 1, 2024