This is no doubt, most asked beginner level java interview question. And sometimes you can face at medium level interviews also. So, my suggestion is to learn it here and for ever.
Lets start with immutability itself. An immutable object is an object which state is guaranteed to stay identical over its entire lifetime. This is really a good definition. Isn’t it? It means that the state of object once initialized, can never be changed anyhow.
Normally immutability in java is achieved through following steps :
- Don’t provide mutator methods for any field
- Make all fields final and private
- Don’t allow subclasses by declaring the class final itself
- Return deep cloned objects with copied content for all mutable fields in class
Please note that while it is possible to implement immutability without "final" keyword, its use makes that purpose explicit, to the human (the software developer) and the machine (the compiler).
Java also has its share of immutable classes which are primarily String class and wrapper classes. In this post, we will understand the need of immutability for String class.
1) Security : The first and undeniably most important reason is security. Well, its not only about your application, but even for JDK itself. Java class loading mechanism works on class names passed as parameters, then these classes are searched in class path. Imagine for a minute, Strings were mutable, then anybody could have injected its own class-loading mechanism with very little effort and destroyed or hacked in any application in a minute.
[ Well, I think in this case java didn’t have got any popularity today… 🙂 and nobody would be using it]. It means Strings were immutable that’s why java is still around in the game.
2) Performance : I believe that it is not the immutability of String class that gives it performance, rather it is string pool which works silently behind the scene. But at the same time, string pool is not a possibility without making String class immutable. So, it all again comes down to immutability of String class which allowed string pools, and thus better performance.
3) Thread safety: Immutable objects are safe when shared between multiple threads in multi-threaded applications. Just understand and learn it. There is no super logic. If something can’t be changed, then even thread can not change it.
As String class is main building block of java programming language, because of its use in class loading mechanism, it was indeed a must use case to prevent the String class from being dirty in case of multiple thread. Immutability does the magic here.
I think its enough reasoning to satisfy the need of interviewer. If after these explanations he is not satisfied, he never will be.
Happy Learning !!
yash
If String is immutable, then why its content can be modified ?
public static void main (String[] args) { String st1= "hello"; s1=s1+" India"; }Lokesh Gupta
The content is not modified. A new string object is created everytime.
Puneet Saneja
Hi Lokesh,
I have 1 query to ask, please help me out:
Is there any way to find out, how many objects would create in my java program. For e.g
String str= “abc”+”xyz”;
Lokesh Gupta
You can get idea from https://docs.oracle.com/javase/6/docs/technotes/tools/share/jvisualvm.html
Sumit
If string is immutable then how can we create its object using new ,i.e, String a= new String (“Test”);
Lokesh
Perhaps you are confusing with singleton and immutability. Singleton prevents instance creation (allows only one). But immutability does not prevent creating new instances, it just prevents the state of instance once it is fully created.
Sumit
Thanks for the prompt response…
i got your point but string is both singleton and immutable and as i know we cannot create instance of a singleton class using new operator but in case of string we can, so i am bit confused .Please help!!!
Lokesh
Where you read that String class is singleton. It’s incorrect.
Thiyagarajan
String is not a singleton. Its immutable only.
shekhar
could not understand about class loading , how does it break ?
sagar
can u post something on class loading architecture and the diff types of loaders.
ankit sharma
hey i’m freeshar i want know about java and future in java
Lokesh Gupta
You will be secured for your lifetime if you managed to be a good programmer.
Anant
Hi, I didn’t understand this statement in above explainations about hacking , “Imagine for a minute, Strings were mutable, then anybody could have injected its own class-loading mechanism with very little effort and destroyed or hacked in any application in a minute” Also ” string pool is not a possibility without making String class immutable” please elaborate little more details on this discussions
Lokesh Gupta
OK. So i got two things to explain. Lets make it clear one by one.
1) We know in java load classes using Class.forName(string). If Strings were mutable, then someone wrote the code to load “java.io.Writer”. This string variable will be in pool. Now, some evil code can access this pool and change the string to “com.MakeHavocWriter” and now when code gets executed, one can easily imagine the consequences.
2) String pool is there so that one String instance can be referred from multiple reference variables. If string is mutable, then one object can change the string content and other will see this undesired value.
See the fact is that String pool was designed for sake of performance, by minimizing the total count of string instances (not references) in application memory space. And as in above scenario, if pool makes the string values changing undesirably, then no one will prefer to use it.
Francois
security is not so obvious , it is mainly for performance, and thread safety i would say/
about security , usually we done want to hack “Oracle java base class” but applicative class
And there if you have a jar with for instance Checkpassword.class can can use decompile it, look on the signature, and change the checkPass() to return true, and wrap it to the jar (as very few jar are signed) and run the application with it. so that you “hack” some how the class loader. and job is done.
as a benefits to immutability and about performace
the hashcode of a string is computed only once (the first time you call hashcode()) , that is a great point about perf ,( string is very often use in hashmap.)
H Singh
Hi Francois,
Can you please elaborate the last para from your reply.
Thanks.