Program to prove String is immutable

Question

In an interview they asked me to write a program to prove String is immutable. I don't have any idea what to write, somebody please help me ?'

Answer 1

use the class sun.misc.Unsafe and change the content of the String, to prove the opposite. You should know when something is impossible.

import sun.misc.Unsafe; import java.lang.reflect.Field;

class Main {
    static Unsafe getUnsafe() throws Throwable {
        Field f = Unsafe.class.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        return (Unsafe) f.get(null);
    }

    public static void main(String[] args) throws Throwable {
        String a = "abcdef";
        Unsafe u = getUnsafe();
        int stringOffset = 40; //this might be platform dependant I used guessing in a loop and keept what whorked.

        System.out.println(a);  // abcdef

        u.putChar(a,stringOffset + 0 * u.ARRAY_CHAR_INDEX_SCALE, 'g');
        u.putChar(a,stringOffset + 1 * u.ARRAY_CHAR_INDEX_SCALE, 'h');
        u.putChar(a,stringOffset + 2 * u.ARRAY_CHAR_INDEX_SCALE, 'i');

        System.out.println(a);  // ghidef
    }
}

you might get warnings because of the usage of Unsafe

Answer 2

To show String is immutable you have to show that once you create one, you won't be able to change it. So you have to show that all public methods of the class don't change it. But you also have to show that you can't inherit from it because that could be a way to break this characteristic (or else that it state couldn't be changed by overriders).

Answer 3

String objects created using string literals are stored in the String Constant Pool and any two objects in the pool can’t have the same content.

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

    String s1 = "java";
    String s2 = "java";

    System.out.println("No modification is made");

    referenceCheck(s1,s2);

    s1 = s1.concat("code");

    System.out.println("After modification");

    referenceCheck(s1,s2);

}


public static void referenceCheck(Object x, Object y)
{
    if(x==y)
    {
        System.out.println("Both objects points to same reference");

    }

    else
    {
        System.out.println("Both pointing to different object");
    }
}

Before modifications, they are pointing to the same object. Once we tried to change the content of the object using ‘s1’, a new object is created in the pool and its reference is assigned to s1. If the strings are mutable, both s1 and s2 should point to the same object even after modification.

Answer 4

To prove for immutability, use the following code:

public class Mutable {

    public static void main(String[] s) {

        String a = "abc";
        String b = a;
        a = a.concat("d");
        System.out.println(a);
        System.out.println(b);

        StringBuffer c = new StringBuffer("abc");
        StringBuffer d = c;
        c.append("d");
        System.out.println(c);
        System.out.println(d);

    }
}

The class which is mutable will show same results since the references of the variables are the same.

Answer 5

    String first = "CATCAT";
    String second = first.replace('A', 'Z');
    System.out.println("First = " + first);
    System.out.println("Second = " + second);

The initial String is still the same.

Answer 6

May be you can do like this

 String str1="String1";  
 String str2 = "String2";  
 System.out.println("str1 " + str1.hashCode());  
 System.out.println("str2 = " + str2.hashCode());  

 str1=str1 + str2;  
 System.out.println("The hashcode str1 changed : " + str1.hashCode());

Hence proved

Answer 7

Here is the following example:

public class Immutable {

    public static void main(String[] args) {
        String str1 = "123";
        String str2 = "123";

        System.out.println(str1 == str2);         //Output : true

        str1 = str2 + "456";

        System.out.println(str1 == str2);         //Output : false
    }
}