What is difference between mutable and immutable String in java

As per my knowledge,

a mutable string can be changed, and an immutable string cannot be changed.

Here I want to change the value of String like this,

String str="Good";
str=str+" Morning";

and other way is,

StringBuffer str= new StringBuffer("Good");
str.append(" Morning");

In both the cases I am trying to alter the value of str. Can anyone tell me, what is difference in both case and give me clear picture of mutable and immutable objects.

Case 1:

String str = "Good";
str = str + " Morning";

In the above code you create 3 String Objects.

1. "Good" it goes into the String Pool.
2. " Morning" it goes into the String Pool as well.
3. "Good Morning" created by concatenating "Good" and " Morning". This guy goes on the Heap.

Note: Strings are always immutable. There is no, such thing as a mutable String. str is just a reference which eventually points to "Good Morning". You are actually, not working on 1 object. you have 3 distinct String Objects.

---

Case 2:

StringBuffer str = new StringBuffer("Good"); 
str.append(" Morning");

StringBuffer contains an array of characters. It is not same as a String. The above code adds characters to the existing array. Effectively, StringBuffer is mutable, its String representation isn't.

> What is difference between mutable and immutable String in java

immutable exist, mutable don't.

In Java, all strings are immutable. When you are trying to modify a String, what you are really doing is creating a new one. However, when you use a StringBuilder, you are actually modifying the contents, instead of creating a new one.

Java Strings are immutable.

In your first example, you are changing the reference to the String, thus assigning it the value of two other Strings combined: str + " Morning".

On the contrary, a StringBuilder or StringBuffer can be modified through its methods.

• Mutable     :- Changeable
• Immutable **:-** Unchangeable

---

String in Java is immutable. However what does it mean to be mutable in programming context is the first question. Consider following class,

public class Dimension {
	private int height;
	
	private int width;
	
	public Dimenstion() {
	}
	
	public void setSize(int height, int width) {
		this.height = height;
		this.width = width;
	}
	
	public getHeight() {
		return height;
	}
	
	public getWidth() {
		return width;
	}
}

Now after creating the instance of Dimension we can always update it's attributes. Note that if any of the attribute, in other sense state, can be updated for instance of the class then it is said to be mutable. We can always do following,

Dimension d = new Dimension();
d.setSize(10, 20);// Dimension changed
d.setSize(10, 200);// Dimension changed
d.setSize(100, 200);// Dimension changed

Let's see in different ways we can create a String in Java.

String str1 = "Hey!";
String str2 = "Jack";
String str3 = new String("Hey Jack!");
String str4 = new String(new char[] {'H', 'e', 'y', '!'});
String str5 = str1 + str2;
str1 = "Hi !";
// ...

So,

1. str1 and str2 are String literals which gets created in String constant pool
2. str3, str4 and str5 are String Objects which are placed in Heap memory
3. str1 = "Hi!"; creates "Hi!" in String constant pool and it's totally different reference than "Hey!" which str1 referencing earlier.

Here we are creating the String literal or String Object. Both are different, I would suggest you to read following post to understand more about it.

• https://stackoverflow.com/questions/3297867/difference-between-string-object-and-string-literal

In any String declaration, one thing is common, that it does not modify but it gets created or shifted to other.

String str = "Good"; // Create the String literal in String pool
str = str + " Morning"; // Create String with concatenation of str + "Morning"
|_____________________|
	   |- Step 1 : Concatenate "Good"  and " Morning" with StringBuilder
	   |- Step 2 : assign reference of created "Good Morning" String Object to str
	   

> How String became immutable ?

It's non changing behaviour, means, the value once assigned can not be updated in any other way. String class internally holds data in character array. Moreover, class is created to be immutable. Take a look at this strategy for defining immutable class.

Shifting the reference does not mean you changed it's value. It would be mutable if you can update the character array which is behind the scene in String class. But in reality that array will be initialized once and throughout the program it remains the same.

> Why StringBuffer is mutable ?

As you already guessed, StringBuffer class is mutable itself as you can update it's state directly. Similar to String it also holds value in character array and you can manipulate that array by different methods i.e. append, delete, insert etc. which directly changes the character value array.

When you say str, you should be careful what you mean:

• do you mean the variable str?

• or do you mean the object referenced by str?

In your StringBuffer example you are not altering the value of str, and in your String example you are not altering the state of the String object.

The most poignant way to experience the difference would be something like this:

static void change(String in) { 
  in = in + " changed";
}

static void change(StringBuffer in) {
  in.append(" changed");
}

public static void main(String[] args) {
   StringBuffer sb = new StringBuffer("value");
   String str = "value";
   change(sb);
   change(str);
   System.out.println("StringBuffer: "+sb);
   System.out.println("String: "+str);
}

In Java, all strings are immutable(Can't change). When you are trying to modify a String, what you are really doing is creating a new one.

Following ways we can create the string object

1. Using String literal

   String str="java";
   

2. Using new keyword

   String str = new String("java");
   

3. Using character array

   char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.' };
   
   String helloString = new String(helloArray);   
   

coming to String immutability, simply means unmodifiable or unchangeable

Let's take one example

I'm initializing the value to the String literal s

String s="kumar";

Below I'm going to display the decimal representation of the location address using hashcode()

System.out.println(s.hashCode());

Simply printing the value of a String s

System.out.println("value "+s);

Okay, this time I'm inittializing value "kumar" to s1

String s1="kumar";   // what you think is this line, takes new location in the memory ??? 

Okay let's check by displaying hashcode of the s1 object which we created

System.out.println(s1.hashCode());

okay, let's check below code

String s2=new String("Kumar");
	System.out.println(s2.hashCode());  // why this gives the different address ??

Okay, check this below code at last

String s3=new String("KUMAR");
	System.out.println(s3.hashCode());  // again different address ???

YES, if you see Strings 's' and 's1' having the same hashcode because the value hold by 's' & 's1' are same that is 'kumar'

Let's consider String 's2' and 's3' these two Strings hashcode appears to be different in the sense, they both stored in a different location because you see their values are different.

since s and s1 hashcode is same because those values are same and storing in the same location.

Example 1: Try below code and analyze line by line

public class StringImmutable {
public static void main(String[] args) {
	
	String s="java";
	System.out.println(s.hashCode());
	String s1="javA";
	System.out.println(s1.hashCode());
	String s2=new String("Java");
	System.out.println(s2.hashCode());
	String s3=new String("JAVA");
	System.out.println(s3.hashCode());
}
}

Example 2: Try below code and analyze line by line

public class StringImmutable {
	public static void main(String[] args) {

		String s="java";
		s.concat(" programming");  // s can not be changed "immutablity"
		System.out.println("value of s "+s);
		System.out.println(" hashcode of s "+s.hashCode());

		String s1="java";
		String s2=s.concat(" programming");   // s1 can not be changed "immutablity" rather creates object s2
		System.out.println("value of s1 "+s1);
		System.out.println(" hashcode of s1 "+s1.hashCode());  

		System.out.println("value of s2 "+s2);
		System.out.println(" hashcode of s2 "+s2.hashCode());

	}
}

Okay, Let's look what is the difference between mutable and immutable.

mutable(it change) vs. immutable (it can't change)

public class StringMutableANDimmutable {
	public static void main(String[] args) {

		
		// it demonstrates immutable concept
		String s="java";
		s.concat(" programming");  // s can not be changed (immutablity)
		System.out.println("value of s ==  "+s); 
		System.out.println(" hashcode of s == "+s.hashCode()+"\n\n");
		
		
		// it demonstrates mutable concept
		StringBuffer s1= new StringBuffer("java");
		s1.append(" programming");  // s can be changed (mutablity)
		System.out.println("value of s1 ==  "+s1); 
		System.out.println(" hashcode of s1 == "+s1.hashCode());


	}
}

Any further questions?? please write on...

I modified the code of william with a output comments for better understandable

   static void changeStr(String in) { 
	  in = in+" changed";
	  System.out.println("fun:"+in); //value changed 
	}
	static void changeStrBuf(StringBuffer in) {
	  in.append(" changed");   //value changed
	}

	public static void main(String[] args) {
	   StringBuffer sb = new StringBuffer("value");
	   String str = "value";
	   changeStrBuf(sb);
	   changeStr(str);
	   System.out.println("StringBuffer: "+sb); //value changed
	   System.out.println("String: "+str);       // value 
	}

In above code , look at the value of str in both main() and changeStr() , even though u r changing the value of str in changeStr() it is affecting only to that function but in the main function the value is not changed , but it not in the case of StringBuffer..

In StringBuffer changed value is affected as a global..

hence String is immutable and StringBuffer is mutable...

In Simple , whatever u changed to String Object will affecting only to that function By going to String Pool. but not Changed...

A mutable variable is one whose value may change in place, whereas in an immutable variable change of value will not happen in place. Modifying an immutable variable will rebuild the same variable.

Mutable means you will save the same reference to variable and change its contents but immutable you can not change contents but you will declare new reference contains the new and the old value of the variable

Ex Immutable -> String

String x = "value0ne";// adresse one x += "valueTwo"; //an other adresse {adresse two} adresse on the heap memory change.

Mutable -> StringBuffer - StringBuilder StringBuilder sb = new StringBuilder(); sb.append("valueOne"); // adresse One sb.append("valueTwo"); // adresse One

sb still in the same adresse i hope this comment helps