I understand String's intern method.
String s1 = "Hello";
String s4 = new String("Hello").intern();
Output of (s1 == s4) will be true, it would be false had we not used intern.
My question is on executing the above two statements, how many objects will be created?? One or two? Will new operator creates one more object?
I understand that String s4 = new String("Hello") will create two objects, but got confused with using intern with it.
It will be two
one for
String s1 = "Hello";
another for
String s4 = new String("Hello")
You should use intern when you need to optimize your code, because comparing string by reference is faster.
As for your statement, only two object will be created.
Note that too much use of intern may cause to a memory exception as they are stored in the PermGen which is normally small, so make sure you configure correctly your JVM.
intern is only useful for repeated compares of the same values, since the intern operation itself is quite expensive.
...how many objects will be created?? One or two?
Two. But only one of them is kept. The other is immediately eligible for garbage collection.
Will new operator creates one more object?
Yes. Briefly. But then you call its .intern method and save the result. Its .intern method will return the same interned string that s1 points to, and so the object created via new is (again) immediately eligible for GC.
We can see this if we look at the bytecode:
public static void main(java.lang.String[]);
Code:
0: ldc #2 // String Hello
2: astore_1
3: new #3 // class java/lang/String
6: dup
7: ldc #2 // String Hello
9: invokespecial #4 // Method java/lang/String."":(Ljava/lang/String;)V
12: invokevirtual #5 // Method java/lang/String.intern:()Ljava/lang/String;
15: astore_2
16: getstatic #6 // Field java/lang/System.out:Ljava/io/PrintStream;
19: aload_2
20: invokevirtual #7 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
23: getstatic #6 // Field java/lang/System.out:Ljava/io/PrintStream;
26: aload_1
27: aload_2
28: if_acmpne 35
31: iconst_1
32: goto 36
35: iconst_0
36: invokevirtual #8 // Method java/io/PrintStream.println:(Z)V
39: return
3-9 create a new String object from "Hello", leaving its reference on the stack, and then we immediately call intern (which pops the reference to the new string from the stack), and store the return value of intern in s4. So the object temporarily created is no longer referenced.
new String(someString).intern() used to be used when someString was a substring of a larger string and you were going to hold onto it for a long time. For most of Java's lifetime, if you did someString = someBigString.substring(10, 20), someString and someBigString referred to the same character array (with all of the characters for someBigString). So if you released someBigString, it was a memory leak -- someString had a reference to characters that it didn't actually use. The idiom fixed that. As of 1.7.0_06, strings don't share char arrays anymore.substring shared underlying char arrays using offset and count well into 1.7 (specifically, until 1.7.0_06 as I mention above). Just look at the source of String.java in 1.7.0_05, specifically lines 1,961 and 645. I must be misunderstanding your comment.substring returns this in the normal case new String(offset + beginIndex, endIndex - beginIndex, value) That's a private constructor that just sets value, offset, and count, causing reuse of the char array.
.intern()at the end of your second line makes it different from this, this, and this.