What is String Interning in Java, when I should use it, and why?
What is Java String interning?
Asked Answered
http://docs.oracle.com/javase/7/docs/api/java/lang/String.html#intern()
Basically doing String.intern() on a series of strings will ensure that all strings having same contents share same memory. So if you have list of names where 'john' appears 1000 times, by interning you ensure only one 'john' is actually allocated memory.
This can be useful to reduce memory requirements of your program. But be aware that the cache is maintained by JVM in permanent memory pool which is usually limited in size compared to heap so you should not use intern if you don't have too many duplicate values.
More on memory constraints of using intern()
On one hand, it is true that you can remove String duplicates by internalizing them. The problem is that the internalized strings go to the Permanent Generation, which is an area of the JVM that is reserved for non-user objects, like Classes, Methods and other internal JVM objects. The size of this area is limited, and is usually much smaller than the heap. Calling intern() on a String has the effect of moving it out from the heap into the permanent generation, and you risk running out of PermGen space.
-- From: http://www.codeinstructions.com/2009/01/busting-javalangstringintern-myths.html
From JDK 7 (I mean in HotSpot), something has changed.
In JDK 7, interned strings are no longer allocated in the permanent generation of the Java heap, but are instead allocated in the main part of the Java heap (known as the young and old generations), along with the other objects created by the application. This change will result in more data residing in the main Java heap, and less data in the permanent generation, and thus may require heap sizes to be adjusted. Most applications will see only relatively small differences in heap usage due to this change, but larger applications that load many classes or make heavy use of the String.intern() method will see more significant differences.
-- From Java SE 7 Features and Enhancements
Update: Interned strings are stored in main heap from Java 7 onwards. http://www.oracle.com/technetwork/java/javase/jdk7-relnotes-418459.html#jdk7changes
"But be aware that the cache is maintained by JVM in permanent memory pool which is usually limited in size ......" Can you explain this ? I didn't understand –
Citizenship
the "interned" strings are stored in a special memory region in the JVM. This memory region has typically a fixed size, and is not part of the regular Java Heap where other data is stored. Due to the fixed size, it may happen that this permanent memory region gets filled up with all your strings, leading to ugly problems (classes cannot be loaded and other stuff). –
Misbeliever
@Misbeliever so, is it similar to caching ? –
Citizenship
myth link is good ! but there are lots of negative reviews for that article –
Citizenship
@grassPro: Yes, it is a kind of caching, one that is natively provided by the JVM. As a note, due to the merge of the Sun/Oracle JVM and JRockit, the JVM engineers try to get rid of the permanent memory region in JDK 8 (openjdk.java.net/jeps/122), so there won't be any size limitation in the future. –
Misbeliever
@cello: Thanks for the link. It talks about native memory. Can you tell how is native memory different from heap. I think when JVM starts as its a process from OS perspective memory is allocated for it. Then different segments are reserved for diff purposes specifically managed by JVM. So what are different parts of it. Can you point me to some link where it is explained. Thanks again –
Ally
Programmers should also be aware that string interning can have security implications. If you have sensitive text such as passwords as strings in memory, it might stay in memory for a very long time even if the actual string objects have long been GC'd. That can be troublesome if bad guys somehow get access to a memory dump. This problem exists even without interning (since GC is non-deterministic to start with etc), but it makes it somewhat worse. It's always a good idea to use
char[] instead of String for sensitive text and zero it out as soon as it's no longer needed. –
Travis I'm just trying to understand the difference between
s2 = s1.intern(); and s2 = s1; –
Prowel If there is s3 = "foo", and
s1.intern() eventually references foo, then s2 = s1.intern(); will point to s3, whereas without the #intern(), s2 = s1` will point to reference of s1 –
Scoville @ARK's explanation is probably correct but seems difficult to understand, so @Kyle Delaney here's another answer to your question. There is no functional difference between your 2 statements—
s2 will contain the same String value (s1's value). The difference lies in which area of memory the string value becomes stored, with internalized being more performant (less resource consuming) potentially in cases where you might otherwise write that value to memory several times. –
Tohubohu There are some "catchy interview" questions, such as why you get equals! if you execute the below piece of code.
String s1 = "testString";
String s2 = "testString";
if(s1 == s2) System.out.println("equals!");
If you want to compare Strings you should use equals(). The above will print equals because the testString is already interned for you by the compiler. You can intern the strings yourself using intern method as is shown in previous answers....
Your example is tricky cause it will result to the same print even if you use the
equals method. You might want to add a new String() comparison to show the distinction more clearly. –
Ming @giannischristofakis but if we use new String(), wouldn't the == fail ? Does java automatically internalise newed strings as well ? –
Pistol
@giannischristofakis of course if you use new String() it will fail on ==. but new String(...).intern() will not fail on == because intern will return the same string. Simple assume compiler is doing new String().intern in literals –
Rainger
JLS
JLS 7 3.10.5 defines it and gives a practical example:
Moreover, a string literal always refers to the same instance of class String. This is because string literals - or, more generally, strings that are the values of constant expressions (§15.28) - are "interned" so as to share unique instances, using the method String.intern.
Example 3.10.5-1. String Literals
The program consisting of the compilation unit (§7.3):
package testPackage; class Test { public static void main(String[] args) { String hello = "Hello", lo = "lo"; System.out.print((hello == "Hello") + " "); System.out.print((Other.hello == hello) + " "); System.out.print((other.Other.hello == hello) + " "); System.out.print((hello == ("Hel"+"lo")) + " "); System.out.print((hello == ("Hel"+lo)) + " "); System.out.println(hello == ("Hel"+lo).intern()); } } class Other { static String hello = "Hello"; }and the compilation unit:
package other; public class Other { public static String hello = "Hello"; }produces the output:
true true true true false true
JVMS
JVMS 7 5.1 says says that interning is implemented magically and efficiently with a dedicated CONSTANT_String_info struct (unlike most other objects which have more generic representations):
A string literal is a reference to an instance of class String, and is derived from a CONSTANT_String_info structure (§4.4.3) in the binary representation of a class or interface. The CONSTANT_String_info structure gives the sequence of Unicode code points constituting the string literal.
The Java programming language requires that identical string literals (that is, literals that contain the same sequence of code points) must refer to the same instance of class String (JLS §3.10.5). In addition, if the method String.intern is called on any string, the result is a reference to the same class instance that would be returned if that string appeared as a literal. Thus, the following expression must have the value true:
("a" + "b" + "c").intern() == "abc"To derive a string literal, the Java Virtual Machine examines the sequence of code points given by the CONSTANT_String_info structure.
If the method String.intern has previously been called on an instance of class String containing a sequence of Unicode code points identical to that given by the CONSTANT_String_info structure, then the result of string literal derivation is a reference to that same instance of class String.
Otherwise, a new instance of class String is created containing the sequence of Unicode code points given by the CONSTANT_String_info structure; a reference to that class instance is the result of string literal derivation. Finally, the intern method of the new String instance is invoked.
Bytecode
Let's decompile some OpenJDK 7 bytecode to see interning in action.
If we decompile:
public class StringPool {
public static void main(String[] args) {
String a = "abc";
String b = "abc";
String c = new String("abc");
System.out.println(a);
System.out.println(b);
System.out.println(a == c);
}
}
we have on the constant pool:
#2 = String #32 // abc
[...]
#32 = Utf8 abc
and main:
0: ldc #2 // String abc
2: astore_1
3: ldc #2 // String abc
5: astore_2
6: new #3 // class java/lang/String
9: dup
10: ldc #2 // String abc
12: invokespecial #4 // Method java/lang/String."<init>":(Ljava/lang/String;)V
15: astore_3
16: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
19: aload_1
20: invokevirtual #6 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
23: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
26: aload_2
27: invokevirtual #6 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
30: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
33: aload_1
34: aload_3
35: if_acmpne 42
38: iconst_1
39: goto 43
42: iconst_0
43: invokevirtual #7 // Method java/io/PrintStream.println:(Z)V
Note how:
0and3: the sameldc #2constant is loaded (the literals)12: a new string instance is created (with#2as argument)35:aandcare compared as regular objects withif_acmpne
The representation of constant strings is quite magic on the bytecode:
- it has a dedicated CONSTANT_String_info structure, unlike regular objects (e.g.
new String) - the struct points to a CONSTANT_Utf8_info Structure that contains the data. That is the only necessary data to represent the string.
and the JVMS quote above seems to say that whenever the Utf8 pointed to is the same, then identical instances are loaded by ldc.
I have done similar tests for fields, and:
static final String s = "abc"points to the constant table through the ConstantValue Attribute- non-final fields don't have that attribute, but can still be initialized with
ldc
Conclusion: there is direct bytecode support for the string pool, and the memory representation is efficient.
Bonus: compare that to the Integer pool, which does not have direct bytecode support (i.e. no CONSTANT_String_info analogue).
Update for Java 8+
In Java 8, PermGen (Permanent Generation) space is removed and replaced by Meta Space. The String pool memory is moved to the heap of JVM.
Compared with Java 7, the String pool size is increased in the heap. Therefore, you have more space for internalized Strings, but you have less memory for the whole application.
One more thing, you have already known that when comparing 2 (referrences of) objects in Java, '==' is used for comparing the reference of object, 'equals' is used for comparing the contents of object.
Let's check this code:
String value1 = "70";
String value2 = "70";
String value3 = new Integer(70).toString();
Result:
value1 == value2 ---> true
value1 == value3 ---> false
value1.equals(value3) ---> true
value1 == value3.intern() ---> true
That's why you should use 'equals' to compare 2 String objects. And that's is how intern() is useful.
Since strings are objects and since all objects in Java are always stored only in the heap space, all strings are stored in the heap space. However, Java keeps strings created without using the new keyword in a special area of the heap space, which is called "string pool". Java keeps the strings created using the new keyword in the regular heap space.
The purpose of the string pool is to maintain a set of unique strings. Any time you create a new string without using the new keyword, Java checks whether the same string already exists in the string pool. If it does, Java returns a reference to the same String object and if it does not, Java creates a new String object in the string pool and returns its reference. So, for example, if you use the string "hello" twice in your code as shown below, you will get a reference to the same string. We can actually test this theory out by comparing two different reference variables using the == operator as shown in the following code:
String str1 = "hello";
String str2 = "hello";
System.out.println(str1 == str2); //prints true
String str3 = new String("hello");
String str4 = new String("hello");
System.out.println(str1 == str3); //prints false
System.out.println(str3 == str4); //prints false
== operator is simply checks whether two references point to the same object or not and returns true if they do. In the above code, str2 gets the reference to the same String object which was created earlier. However, str3 and str4 get references to two entirely different String objects. That is why str1 == str2 returns true but str1 == str3 and str3 == str4 return false . In fact, when you do new String("hello"); two String objects are created instead of just one if this is the first time the string "hello" is used in the anywhere in program - one in the string pool because of the use of a quoted string, and one in the regular heap space because of the use of new keyword.
String pooling is Java's way of saving program memory by avoiding the creation of multiple String objects containing the same value. It is possible to get a string from the string pool for a string created using the new keyword by using String's intern method. It is called "interning" of string objects. For example,
String str1 = "hello";
String str2 = new String("hello");
String str3 = str2.intern(); //get an interned string obj
System.out.println(str1 == str2); //prints false
System.out.println(str1 == str3); //prints true
String interning is an optimization technique by the compiler. If you have two identical string literals in one compilation unit then the code generated ensures that there is only one string object created for all the instance of that literal(characters enclosed in double quotes) within the assembly.
I am from C# background, so i can explain by giving a example from that:
object obj = "Int32";
string str1 = "Int32";
string str2 = typeof(int).Name;
output of the following comparisons:
Console.WriteLine(obj == str1); // true
Console.WriteLine(str1 == str2); // true
Console.WriteLine(obj == str2); // false !?
Note1:Objects are compared by reference.
Note2:typeof(int).Name is evaluated by reflection method so it does not gets evaluated at compile time. Here these comparisons are made at compile time.
Analysis of the Results: 1) true because they both contain same literal and so the code generated will have only one object referencing "Int32". See Note 1.
2) true because the content of both the value is checked which is same.
3) FALSE because str2 and obj does not have the same literal. See Note 2.
It's stronger than that. Any String literal loaded by the same classloader will refer to the same String. See the JLS and JVM Specification. –
Blender
@Blender in fact, it is even irrelevant to which classloader the string literal belongs. –
Ortega
In fact it is an optimization by the JVM, not by the compiler. The compiler does string pooling, and the JLS says it does so via
String.intern(), which is hard to believe, but you can call String.intern() yourself at any time, which has nothing to do with the compiler at all. –
Blender Java interning() method basically makes sure that if String object is present in SCP, If yes then it returns that object and if not then creates that objects in SCP and return its references
for eg: String s1=new String("abc");
String s2="abc";
String s3="abc";
s1==s2// false, because 1 object of s1 is stored in heap and other in scp(but this objects doesn't have explicit reference) and s2 in scp
s2==s3// true
now if we do intern on s1
s1=s1.intern()
//JVM checks if there is any string in the pool with value “abc” is present? Since there is a string object in the pool with value “abc”, its reference is returned.
Notice that we are calling s1 = s1.intern(), so the s1 is now referring to the string pool object having value “abc”.
At this point, all the three string objects are referring to the same object in the string pool. Hence s1==s2 is returning true now.
By using heap object reference, if we want to corresponding SCP object reference we should go for intern() method.
Example :
class InternDemo
{
public static void main(String[] args)
{
String s1=new String("smith");
String s2=s1.intern();
String s3="smith";
System.out.println(s2==s3);//true
}
}
What is SCP? and please don't post links to images. Please don't post images at all if you can help it, and certainly not via links. –
Blender
© 2022 - 2024 — McMap. All rights reserved.
String a = new String("abc");String b = new String("abc");thena.intern() == b.intern()– AnjaanjaliString.intern()depend onClassLoader, meaning, Do different classloader's creating "different"Strings, causing differentinterns? – Ravid