When and Why Would You Use `new String(...)` in Java?

String Constant Assignment to String Objects in Java: Understanding "new String(...)"

While examining code samples, you may have encountered assignments of String constants to String objects using the "new" operator. This syntax raises questions about its purpose and effects, especially considering the typical storage of String constants in the constant pool.

Purpose of "new String(...)"

The primary purpose of "new String(...)" is to create a new String object that contains a copy of the specified String literal. Unlike "s = "Hello World";", which references the existing String literal stored in the constant pool, "s = new String("Hello World");" creates a new object in the heap with its own character array backing store.

Allocation on the Heap

Yes, in the case of "new String(...)", a new object is allocated on the heap to store the String's value. This is in contrast to referencing an existing String literal in the constant pool.

Use Case and Implementation Dependency

In certain scenarios, you may want to force a distinct copy of the internal character array using "new String(...)". For example:

small = new String(huge.substring(10, 20))

However, this behavior is undocumented and implementation dependent. Different Java Virtual Machines (JVMs) may handle this expression differently.

Pitfalls and Limitations

An earlier implementation of String(String) in Apache Harmony did not actually create a copy of the underlying character array. This can lead to potential memory issues, such as keeping a reference to a large character array even when it is no longer needed.

To create a new String object with a separate copy of the characters, it is necessary to use:

small = new String(huge.substring(10, 20).toCharArray());

This approach ensures a distinct copy of the characters but requires two array copies, which can be inefficient.

Conclusion

The "new String(...)" expression creates a new String object in the heap that contains a copy of the specified String literal. While it can be useful in certain scenarios, it is important to be aware of its potential pitfalls and implementation dependencies to avoid unexpected behavior.

The above is the detailed content of When and Why Would You Use `new String(...)` in Java?. For more information, please follow other related articles on the PHP Chinese website!