Differences Between String Creation in Java: new() vs Literal

In Java, how is creating a String using new() different from creating a text? Explain in detail, preferably from the source code perspective

In Java, there are two primary ways to create a String: using the new keyword and using string literals. While both methods ultimately create a String object, they differ in how they manage memory and how they interact with the Java String pool.

1. Creating a String using new

When you create a String using the new keyword, you explicitly create a new instance of the String class. For example:

String str1 = new String("Hello");

In this case, the following happens:

• A new String object is created in the heap memory, regardless of whether an equivalent string already exists in the String pool.
• The String constructor is called, which initializes the new object with the value "Hello".

From the source code perspective, the String class has a constructor that looks like this:

public String(String original) {
    this.value = Arrays.copyOf(original.value, original.value.length);
    this.hash = original.hash;
}

This constructor copies the character array from the original string to create a new String object.

2. Creating a String using a String Literal

When you create a String using a string literal, like this:

String str2 = "Hello";

The following occurs:

• The Java compiler checks the String pool (a special area of memory in the heap) to see if a String with the value "Hello" already exists.
• If it does exist, str2 will reference that existing String object.
• If it does not exist, a new String object is created in the String pool, and str2 will reference that object.

The String pool is a part of the Java heap memory that stores unique string literals. This mechanism helps save memory and improves performance by reusing immutable String objects.

Key Differences

1. Memory Allocation:

   • new String(...): Always creates a new String object in the heap, even if an equivalent string exists in the String pool.
   • String literal: Reuses existing String objects from the String pool if they already exist.

2. Performance:

   • new String(...): Generally less efficient due to the overhead of creating a new object every time.
   • String literal: More efficient as it can reuse existing objects.

3. Identity vs. Equality:

   • When comparing two strings created with new String(...), they will not be equal using == because they reference different objects in memory.
   • String literals can be equal using == if they reference the same object in the String pool.

Example

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

System.out.println(str1 == str2); // false, different objects
System.out.println(str2 == str3); // true, same object in the pool
System.out.println(str1.equals(str2)); // true, same content

Conclusion

In summary, using new String(...) creates a new object in the heap memory, while using string literals leverages the String pool for memory efficiency. Understanding these differences is crucial for effective memory management and performance optimization in Java applications.