Difference between Mutable & Immutable objects

Question

string is immutable what does actually it means...
though i have read some docs on net...
i could not gained complete understanding

Answer 1

Mutable objects are able to be changed like an integer
value for example:
i = 5;
i++; // I will now be equal to 6Only objects can be mutable/immutable, references to objects and primitive variables are not objects and
the value itself cannot be changed, only the contents of the variable itself can be changed.
Example
String a = "123";
String b = "456";
//** Both a and b refer to 2 different Strings
String c = b;
//** c now refers to the "456"
b = a;
//** b now points to "123" and has the same reference as a
//** Note, no changes to the actual objects themselves have been made so (im)mutability is not relevant
//** For primitives
int d = 1;
int e = 2;
//** e and d have different values, they "refer" to the integer constants 1 and 2 if you like
int f = e;
//** f has the same value as e, f and e refer to the integer constant 2
f++;
//** f has been incremented, it now "refers" to the integer constant 3, changing its value has not changed the value of eThis is important because Java passes things around by value not by reference.
When you have an object reference as a method parameter, the actual value of the parameter passed to
the method is the reference itself. This value you cannot change.
If Java were pass by reference then you could be able to actually change the value of that reference which means you
could end up pointing to a different part of the heap.
Example
int a = 5;
StringBuffer buff = new StringBuffer();
String b = "123";
//** primitive, mutable and immutable
//** call some method that takes these as parameters
System.out.println( someMethod( a, buff, b ) );
System.out.println( a );
//** the method has the following code
public StringBuffer someMethod( int a, StringBuffer buff, String b ) {
  buff.append( b );
  buff = new StringBuffer( b + a );
  a++;
  return buff;
}The above code is legal, I can reassign values to parameters that are not marked as final.
What cannot happen is that the values passed to the method can change.
The append call to buff means that the StringBuffer passed has been altered.
The assignment to buff of a new StringBuffer in no way changes the value of the reference, the original reference remains unchanged, in otherwords the buff variable outside the method call still points to its original object.
The increment of the parameter a does not change the value of the integer, you are reassigning a new value to a.
The value of int a outside the method call remains unchanged, the value passed to the method also remains unchanged.
Remember that variables are simply placeholders for things, in this case values. Primitive operators result in the variable value being replaced.
A integer value cannot be changed, 1 is always going to be 1, the same is true for any primitive datatypes.