«Back to Home

Core Java
Topics

Difference Between String And StringBuffer In Java

Differentiate Between String And StringBuffer
 
String is an object which represents sequence of char values. Java platform provides the String class to create and manipulate strings.
 
In Java, We know that string is immutable. It cannot be changed but a new instance is created. That’s why we use StringBuffer and StringBuilder class for mutable class.
 
StringBuffer class is used to create for mutable string that means we can modify class through StringBuffer class in Java.
 
The StringBuffer class is similar as String class except it is mutable. It can be changed easily.
 
Let’s see the differences between String and StringBuffer are given below.

 String  StringBuffer
String is immutable (if once we created, cannot be modified) object. StringBuffer is mutable (it can be modified) object.
String performance is very slow and consumes more memory at the time of concatenate strings because every time it creates new instance. StringBuffer performance is faster than string and it consumes less memory at the time of concatenate strings.
String class overrides the equals() method of object class. With the use of it we can compare the contents of two strings. StringBuffer class doesn’t overrides the equals() method of object class.
The object created as a string is takes memory or stored in the constant String Pool. The object created through StringBuffer is stored in the heap memory.
For example:
String str = “Marria”;
str = “Harry”;
  
For example:
StringBuffer str = new StringBuffer(“Peter”);
str.append(“Jones”);
 
Let’s check the performance of String and StringBuffer.
 
Code
  1. public class PerformanceTest {  
  2.     public static String concatString() {  
  3.         String concat = "Peter";  
  4.         for (int i = 0; i < 10000; i++) {  
  5.             concat = concat + "Jon";  
  6.         }  
  7.         return concat;  
  8.     }  
  9.     public static String concatStringBuffer() {  
  10.         StringBuffer concat = new StringBuffer("Harry");  
  11.         for (int i = 0; i < 10000; i++) {  
  12.             concat.append("Tom");  
  13.         }  
  14.         return concat.toString();  
  15.     }  
  16.     public static void main(String[] args) {  
  17.         long startTime = System.currentTimeMillis();  
  18.         concatString();  
  19.         System.out.println(" Concating String performance: " + (System.currentTimeMillis() - startTime) + "ms");  
  20.         startTime = System.currentTimeMillis();  
  21.         concatStringBuffer();  
  22.         System.out.println(" Concating StringBuffer performance: " + (System.currentTimeMillis() - startTime) + "ms");  
  23.     }  
  24. }  
19

Output

16

Now, let’s check the String and StringBuffer HashCode Test.
 
Code
  1. public class HashcodeTest {  
  2.     public static void main(String args[]) {  
  3.         System.out.println("String Hashcode test:");  
  4.         String h = "David";  
  5.         System.out.println(h.hashCode());  
  6.         h = h + "Jones";  
  7.         System.out.println(h.hashCode());  
  8.         System.out.println("StringBuffer Hashcode test:");  
  9.         StringBuffer s = new StringBuffer("Mia");  
  10.         System.out.println(s.hashCode());  
  11.         s.append("Jones");  
  12.         System.out.println(s.hashCode());  
  13.     }  
  14. }  
17
 
Output

18

In the program above example, we can see that string returns new hashcode value when we concat string but StringBuffer returns same hashcode value when we concat stringBuffer.
 
Summary

Thus, we learned that String is immutable. It cannot be changed but a new instance is created and StringBuffer class is same as String class except it is mutable. It can be changed easily and also learn their differences between in Java.