Advertisement

---

Top

< Prev

Next >

Differences between String and StringBuilder

All the differences we've described in our article String vs StringBuffer also apply when we compare String with StringBuilder class, as StringBuilder and StringBuffer class are quite similar.

1) A string created by String class is immutable i.e. it's original value can't be modified. But a string created by StringBuilder class can be modified easily, hence it is mutable.

2) Trying to modify a string created by String class does not modify it but instead a new string is created, which leads to memory waste, but no memory is wasted when a string created by StringBuilder is modified. Let's understand these differences.

Modification of String object.

Take a look at a short code and implication of its execution in the memory -

String s1= new String("Blue"); //Statement1
String s2= new String("Sky"); //Statement2
s1= s1.concat(s2); 		//Statement3

Figure 1 represents the Heap memory after executing the above three statements. Dashed line indicates a deleted old reference.

• Statement1 creates a String object Blue, it is initially pointed by reference variable s1.
• Statement2 creates a String object Sky, pointed by reference variable s2.
• Statement3 calls concat() method to modify the String pointed s1 by adding String pointed by s2 to it.
• Doing so gives us a new String object BlueSky, now pointed by s1. The original string Blue which we wanted to modify is not modified, proving the point that String objects are immutable, moreover String object Blue is now not even referenced by any variable(see Figure 1), leading to memory waste.

Advertisement

Modification of StringBuilder object.

The memory waste doesn't happen when we try to modify the strings created by StringBuilder class because StringBuilder works directly with original object to modify it.
let us understand by an example-

StringBuilder s1= new StringBuilder("Blue"); // Statement 1
StringBuilder s2= new StringBuilder("Sky");  // Statement 2
s1.append(s2);		  		     // Statement 3

Figure 2 represents the Heap memory after executing the above three statements.

• Statement 1 creates a StringBuilder object Blue, referenced by sb1.
• Statement 2 creates a StringBuilder object World, referenced by sb2.
• Statement 3 has modified StringBuilder object Blue by appending Sky to it, giving us the modified StringBuilder object BlueSky. There is no loss of original object as we have modified the original StringBuilder object.

StringBuilder example

// StringBuilder Class Example

class StringBuilderEx
{
public static void main(String... ar)
{
StringBuilder sb= new StringBuilder("Never ");

System.out.println("Original String is : "+ sb);
sb.append("Give Up");
System.out.println("Modified String is : "+ sb);
}
}

Output is :

Original String is : Never 
Modified String is : Never Give Up

Program Analysis

• We have created a StringBuffer object that points to a string of characters Never .
• We have called append() method to append a String Give up to our StringBuffer object.
• Post the call to append() method, the original StringBuffer object points to the modified string of characters Never Give Up, pointed by reference sb hence, no object is lost

Please share this article -

< Prev

Next >

< StringBuilder class

StringBuilder methods >

Advertisement