In my last article, I covered strings. We learned about string immutability and the concept of pass-by-value. If you haven't read it yet, please do check it out. Now, it's important to understand why String Builder was created in the first place, which is more important than how to use it. In this blog, I won't be telling you how to use String Builder, as I believe you can figure it out on your own. Instead, I'll explain the reasons for its existence. Let's get started!

StringBuilder

Java StringBuilder class is used to create mutable (modifiable) String. It shares some similarities with the String class but has a crucial difference. It allows modifications without creating new objects. This results in better performance and memory efficiency.

Let's understand this with a simple example:

Consider the following code snippet using the String class:

public class Test {
    public static void main(String[] args) {
        String series = "";
        for (int i = 0; i < 26; i++) {
            char ch = (char) ('a' + i);
            series += ch + " ";
        }
        System.out.println(series); // a b c d e f g h i j k l m n o p q r s t u v w x y z 
    }
}

In this code, we are building the 'series' string by adding characters to it in each iteration of the loop. However, using the String class for this approach can lead to two main problems:

1. Memory and Time Inefficiency: With each iteration, a new string object is created to hold the updated 'series,' leading to unnecessary memory usage and time consumption.

2. Time Complexity: Due to the repeated creation of new objects, the time complexity becomes O(n^2), where 'n' is the number of characters in the final series.

To overcome these issues, we use StringBuilder, as demonstrated in the following code:

public class Stringbuilder {
    public static void main(String[] args) {
        StringBuilder series = new StringBuilder();
        for (int i = 0; i < 26; i++) {
            char ch = (char) ('a' + i);
            series.append(ch).append(" ");
        }

        System.out.println(series.toString()); //a b c d e f g h i j k l m n o p q r s t u v w x y z 
    }
}

In above example, we use StringBuilder to construct the 'series' string. With each iteration, the StringBuilder object appends a new character, avoiding the creation of unnecessary string objects. This significantly improves both time and space efficiency.

By using StringBuilder, we achieve a linear time complexity of O(n) for building the 'series' string, where 'n' is the number of characters in the final series. This makes the code more efficient and scalable compared to using the String class.

There is only one downside to using the StringBuilder class that it does not provide synchronization. This means that instances of the StringBuilder class cannot be safely shared between multiple threads. If you are performing string manipulations in a single-threaded environment, it is recommended to use StringBuilder because it is faster.

I hope you learned something from this blog. If you have, don't forget to drop a like, follow me on Hashnode, and subscribe to my Hashnode newsletter so that you don't miss any future posts. You can also reach out to me on Twitter or LinkedIn. If you have any questions or feedback, feel free to leave a comment below. Thanks for reading and have a great day!