Unexpected behaviour of String pool

Question

I have the following Test:

public class EqualityTest
{
    String one = new String("Hello world");
    String two = new String("Hello ") + new String("world");

    @Test
    public void testStringPool()
    {
        assertFalse(one == two); // FALSE!!!
        assertTrue(one.equals(two));
        assertTrue(one.intern().equals(two.intern()));
    }
}

I would have expected that due to the String pool nature of Java, the VM would allocated one and two pointing to the same String in the pool. Why is my understanding wrong in this case?

That's not a duplicate. This question is about string interning. — Robert Harvey, Oct 22 '12 at 16:13
@RobertHarvey You are right, sort of duplicate answer but not duplicate question I guess. — assylias, Oct 22 '12 at 16:14
Worth noting: in C#, this works correctly, as comparing the reference of two strings is not particularly meaningful in the majority of cases. See http://stackoverflow.com/questions/1659097/c-string-equals-vs. — Robert Harvey, Oct 22 '12 at 16:18
@RobertHarvey Who do you compared reference to objects in C# then? That seems backward (even more so than Java) as `==` just compared references the method in String.class, which is overridden from Object the Object class (.equals) test for value equality. Is this the same in C# - sorry for being off topic, I'm just puzzeled. — TheBlueCat, Oct 22 '12 at 16:59
@TheBlueCat: For comparing references, you can use [`ReferenceEquals()`](http://msdn.microsoft.com/en-us/library/system.object.referenceequals%28v=vs.71%29.aspx). The point is, in C#, `==` is used for the more common scenario of comparing two strings letter by letter. — Robert Harvey, Oct 22 '12 at 17:03
@RobertHarvey So there's two 'ways' to test for equal value? — TheBlueCat, Oct 22 '12 at 17:06
@TheBlueCat: Yes, `==` and `Equals()` work the same for strings. See http://msdn.microsoft.com/en-en/library/362314fe.aspx. It says, *"Although string is a reference type, the equality operators (== and !=) are defined to compare the values of string objects, not references. This makes testing for string equality more intuitive."* — Robert Harvey, Oct 22 '12 at 17:12

score 10 · Accepted Answer · answered Oct 22 '12 at 16:11

I would have expected that due to the String pool nature of Java, the VM would allocated one and two pointing to the same String in the pool.

Only string constants are interned automatically. So if your code had been:

String one = "Hello world";
String two = "Hello " + "world";

... then one and two would have had the same value. Because you've used new String(...), these expressions aren't constant expressions, and so they aren't interned. (The literals are still interned, of course... but not the strings created from the literals.)

See section 15.28 of the JLS for details on what counts as a constant expression.

Rohit Jain · Answer 2 · 2012-10-22T16:29:25.493

4

Whenever you use new operator, a new object is always created on Heap. So, even if the String "Hello World" is available in the Literal Pool, it will not be referenced. So in fact you are creating 4 objects on Heap: -

Hello World ----> new String("Hello World");
Hello ----> new String("Hello");
World ----> new String("World");
And again, Hello World ----> new String("Hello") + new String("World");

Apart from them, there would be 3 literals created on Literal Pool - "Hello World", "Hello" and "World"

So, 7 objects in total.

On the other hand, had you created your Strings using: -

String str = "Hello World";
String str2 = "Hello " + "World";

Again, here 3 literals would be created on Literal Pool - "Hello World", "Hello " and "World", but the concatenation of the last two literals will reference the first literal.

And hence the two String reference point to same literals, and hence they would be equal now.

edited Oct 22 '12 at 16:29

answered Oct 22 '12 at 16:10

Rohit Jain

209,639
45
409
525

2

I count more than 4: `Hello world` literal, `one` object, `two` object, `Hello` literal, `world` literal, `new String("Hello")` object and `new String("world")` object => I'd say 7 objects. – assylias Oct 22 '12 at 16:11
@assylias. Yeah, I missed out literals. Thanks :) – Rohit Jain Oct 22 '12 at 16:13
or you could have used the `+=` operator to be more terse. – TheBlueCat Oct 22 '12 at 17:01
@TheBlueCat And where exactly? – Rohit Jain Oct 22 '12 at 17:02
`String str = "Hello"; String str2 += "World";` – TheBlueCat Oct 22 '12 at 17:05
@TheBlueCat. Yeah, but I was just showing an alternative to create the same objects as OP was using. You see there, I have just removed `new String()`. – Rohit Jain Oct 22 '12 at 17:07
@TheBlueCat. Yo BlueCat. Its ok. :) – Rohit Jain Oct 22 '12 at 17:09

score 0 · Answer 3 · answered Oct 22 '12 at 16:16

Whenever new String ("xyz") is used for creating String object, a new object reference will be created.

For example : when you are dealing with just literals then String pool nature will be used.

String one = "Hello world";
String two = "Hello "+ "world";

System.out.println(one==two);

will print true.

Unexpected behaviour of String pool

3 Answers3