String Constant Pool: Interning and Referencing
The concept of a "String Constant Pool" in Java plays a crucial role in string memory management. String literals, when encountered by the compiler, are interned within the pool. This means that if a String object with the same value already exists in the pool, the reference to the existing object is used instead of creating a new one.
However, when the "new" keyword is encountered before a String literal, the JVM is obligated to create a new String object. This may seem contradictory to the earlier statement regarding interning. To understand this behavior, it's important to note that while the reference to the String literal may exist in the pool, using "new" causes the creation of a new object rather than using the existing one.
To illustrate this concept, consider the following example:
String one = new String("test"); String two = "test";
In this scenario, the literal "test" is interned in the pool, resulting in a reference in both the pool memory and non-pool memory. However, because "new" was used, the JVM creates a new String object for "test" and assigns it to the reference "one."
Now, comparing "one" and "two" using "equals" will return true, indicating that they contain the same value. However, using "==" returns false, confirming that they refer to different objects.
System.out.println(one.equals(two)); // true System.out.println(one == two); // false
The statement "When the compiler encounters a String literal, it checks to see if an identical String already exists in the pool" can be clarified as: Strings are only placed in the pool when they are explicitly interned or used as literals within the class. If a String is created through other means (e.g., concatenation or user input), it may exist with the same value but will not be present in the pool.
The above is the detailed content of String Constant Pool: When Does \"new\" Create a New String Object?. For more information, please follow other related articles on the PHP Chinese website!