String vs StringBuilder vs StringBuffer in Java

String, StringBuilder, and StringBuffer are all classes in Java that are used for working with strings. However, they have significant differences in terms of their functionality, performance, and thread safety. In this article, we will explore the differences between these classes and when to use them.

String class in Java

A String is a sequence of characters in Java, and objects of String are immutable, meaning they cannot be changed once created. Whenever a new String is created, a new object is also created in memory, which can result in significant memory overhead when dealing with large strings. However, because String objects are immutable, they are inherently thread-safe.

StringBuilder and StringBuffer classes in Java

StringBuilder and StringBuffer classes are used when we want to modify a string object. Both classes are mutable, meaning we can change the object's content without creating a new object. However, the difference lies in thread safety.

StringBuffer is thread-safe, meaning that it ensures that only one thread can access the object at a time. This is done by synchronizing the methods, which can result in performance overhead. StringBuilder, on the other hand, is not thread-safe, which means it does not synchronize its methods. This results in better performance, but it is not suitable for multithreaded environments.

Examples

Let's look at an example program that demonstrates the difference between String, StringBuilder, and StringBuffer:

java
class StringDemo {
   public static void main(String args[]) {
      String str1 = "Hello";
      String str2 = "World";

      // Concatenating Strings using String
      String str3 = str1 + str2;

      // Concatenating Strings using StringBuilder
      StringBuilder sb1 = new StringBuilder();
      sb1.append(str1);
      sb1.append(str2);
      String str4 = sb1.toString();

      // Concatenating Strings using StringBuffer
      StringBuffer sb2 = new StringBuffer();
      sb2.append(str1);
      sb2.append(str2);
      String str5 = sb2.toString();

      System.out.println("Using String: " + str3);
      System.out.println("Using StringBuilder: " + str4);
      System.out.println("Using StringBuffer: " + str5);
   }
}

Output:

vbnet
Using String: HelloWorld
Using StringBuilder: HelloWorld
Using StringBuffer: HelloWorld

In this program, we have concatenated two strings, "Hello" and "World," using String, StringBuilder, and StringBuffer. We can see that the output of all three methods is the same. However, the way each class concatenates the strings is different. String concatenation results in a new object creation, whereas StringBuilder and StringBuffer modify the existing object.

When to use String, StringBuilder, or StringBuffer

• Use String when the value is not going to change, and the string is going to remain constant throughout the program. Since the String class is immutable, it is inherently thread-safe.
• Use StringBuilder when the string can change and will only be accessed from a single thread. StringBuilder is not thread-safe, but it is faster than StringBuffer.
• Use StringBuffer when the string can change and will be accessed from multiple threads. StringBuffer is thread-safe, meaning that only one thread can access the object at a time.

Conversion between types of strings in Java

Sometimes, there is a need to convert a string object of different classes like String, StringBuffer, and StringBuilder to one another. Below are some techniques to do the same.

From String to StringBuffer and StringBuilder:

We can directly pass the String object to the StringBuffer and StringBuilder class constructors.

java
String str = "Hello";
StringBuffer sb1 = new StringBuffer(str);
StringBuilder sb2 = new StringBuilder(str);

From StringBuffer and StringBuilder to String:

Both classes have an overridden toString() method, which we can use to convert their contents to a String. For example, suppose we have a StringBuilder object called sb, we can call its toString() method to get a String representation of its contents as follows:

java
StringBuilder sb = new StringBuilder("Hello");
String str = sb.toString();

Similarly, we can use the toString() method to convert a StringBuffer object to a String:

java
StringBuffer sb = new StringBuffer("Hello");
String str = sb.toString();

The toString() method returns a new String object that contains a copy of the characters in the original StringBuilder or StringBuffer object.

It's worth noting that while StringBuilder and StringBuffer are very similar in functionality, the latter is synchronized, which means it's thread-safe. This means that multiple threads can access a StringBuffer object simultaneously without any problems. StringBuilder, on the other hand, is not synchronized and is therefore faster when used in a single-threaded environment.

In general, it's a good idea to use StringBuilder when you know that only one thread will be accessing the object, and StringBuffer when you need to share the object across multiple threads.