Java String immutable passed by reference/value

The line b+="de"; in the void f(String b) functions creates a completely new object of String that does not affect the object in the main function.

So when we say String is immutable when mean any change on a String object will result in creating a completely new String object

public class Test {
    public static void main(String[] args){
        String a =new String("abc");

        String b = a; // both a & b points to the same memory address

        f(b); // has no effect

        // b still has the value of "abc"
        b+="fg" // a new String object that points to different location than "a"

        System.out.println(a + " " + b); // should print "abc abcfg" 
    }

 public static void f(String b){
    b+="de";  // creates a new object that does not affect "b" variable in main
    b=null;
 }
}

This line of code:

b += "de";

Roughly translates to:

b = b + "de";

Which creates a new String and stores it in the local variable 'b'. The reference outside the method is not changed in anyway by this. There are a couple of key things to remember when trying to understand how/why this works this way.

1. In Java, all method arguments are passed by value.
2. Methods have a local stack where all their data is stored, including the method arguments.

When you assign a new object to a variable that was passed into a method, you are only replacing the address in the local stack, with the address of the new object created. The actual object address outside of the method remains the same.

When you pass the String into the method, it creates a new String object in the method. If you put a println statement in your method, like this:

public static void f(String b){
    b+="de";
    System.out.println(b);
    b=null;
}

You would see the output "abcde".

However, once you come out of the method, you go back to your original object, which has not been altered. Therefore, appending fg to it will only produce a NEW string (b), containing "abcfg".

Your creating a new object of String when you say something like b+="de"

Its like saying b = new String(b+"de");

If you really want to keep the value passed in then use a stringBuilder like this:

    StringBuilder a =new StringBuilder("abc");
        StringBuilder b = a;
        f(b);
        b.append("fg");
        System.out.println(a + " " + b);
    }

  public static void f(StringBuilder b){
        b.append("de");
        b=null;
    }

Now your output will be "abcdefg" because stringbuilder object b was passed into f as the value of the object itself. I modified the value without using "new" to point to another object. Hope its clear now.