StringBuffer

StringBuilder, as you might already know, is a powerful tool that provides you with mutable strings. However, it may not be the best solution in situations where multiple threads need to modify the same StringBuilder object simultaneously. That's where StringBuffer comes in. It is a peer class to StringBuilder, with an additional feature: synchronization (a mechanism that ensures that only one thread can access a shared resource at a time, preventing race conditions and other concurrency issues). This makes StringBuffer thread-safe and a better choice for multi-threaded environments. However, there is a trade-off between synchronization and performance, which we will talk more about later on.

Constructors of StringBuffer

Similar to the case of StringBuilder, we have various ways to create a StringBuffer object. We can initialize it as an empty object, set it with a suitable initial content (String or CharSequence), or specify a starting capacity.

• An empty StringBuffer with a default initial capacity (16 bytes) can be created using the default constructor:

val buffer = StringBuffer()

• You can also create a StringBuffer with some initial content by passing a String to the constructor:

val buffer = StringBuffer("Kotlin")

• If you want to specify the capacity of the StringBuffer at the time of creation, you can pass an Int to the constructor:

val buffer = StringBuffer(10) // creates a StringBuffer with an initial capacity of 10 characters

Methods of StringBuffer

StringBuffer shares many similar methods with StringBuilder, so we will briefly mention a few of them as a reminder. However, it's important to note that there is a crucial difference under the hood. A closer look at the StringBuffer class inside the java.lang library reveals that all StringBuffer methods are marked with the synchronized modifier. This is what makes StringBuffer synchronized and thread-safe, allowing it to be used by multiple threads without the need for external synchronization.

Now, let's review those methods:

val buffer = StringBuffer("Kotlin")

println("Length: ${buffer.length}")       // "Length: 6"
println("Capacity: ${buffer.capacity()}") // "Capacity: 22" (initial capacity + length of String passed to constructor = 16 + 6)

val secretMessage = StringBuffer()

secretMessage
    .append("like")
    .insert(3, "srepyHigh")
    .delete(9, 13)
    .replace(0, 1, "ll")
    .reverse()

println(secretMessage) // "Hyperskill"

Proper usage of each class

It's important to choose the right class for a certain job. Depending on your specific requirements and constraints, either StringBuilder or StringBuffer might be the more suitable choice. Let's explore some real-world scenarios to help you make informed decisions.

Best scenarios for using StringBuilder:

1. String concatenation: If you're working on tasks that involve heavy string concatenation operations, such as generating dynamic SQL queries or constructing large JSON/XML payloads, StringBuilder is an excellent choice. Its mutable nature allows for efficient appending of strings, reducing memory consumption and avoiding unnecessary object creations.

2. Logging and formatting: When logging or formatting messages that involve dynamic or variable data, StringBuilder proves beneficial. By appending different values or variables to the StringBuilder, you can efficiently build complex log messages or formatted strings without unnecessary overhead.

3. Generating HTML or XML markup: When dynamically generating HTML or XML markup, StringBuilder can be a suitable choice. It allows you to efficiently build the structure and content of the markup by appending tags, attributes, and values without incurring unnecessary overhead.

Best scenarios for using StringBuffer:

1. Concurrent data processing: When processing data concurrently in a multi-threaded environment, StringBuffer can be used to safely manipulate shared strings. For example, if multiple threads need to extract and process data from a shared log file or data stream, StringBuffer can be used to ensure that the data is consistently and accurately processed.

2. Multi-threaded text generation: In applications that generate text concurrently, such as report generation or document formatting, StringBuffer can be used to safely build the final text output. By using StringBuffer, multiple threads can append text to the shared buffer without worrying about synchronization issues.

3. Thread-safe string caching: In applications that cache frequently used strings, such as web servers or database systems, StringBuffer can be used to implement a thread-safe cache. By using StringBuffer, multiple threads can safely access and manipulate the cached strings without data corruption or inconsistencies.

Converting StringBuffer to String

Converting a StringBuffer to a String allows you to obtain an immutable representation of the modified content for further processing or passing it to methods that expect a String parameter. This can be achieved using the toString method:

val buffer = StringBuffer("Hyperskill")
val string = buffer.toString()
println(string) // "Hyperskill"

The toString method returns a new String object that represents the content of the StringBuffer. Therefore, any subsequent changes made to the StringBuffer after calling toString will not affect the String object. It is important to convert a StringBuffer to a String when you no longer need to modify the content or want to ensure its immutability.

The price of synchronization

When trying to choose between StringBuilder and StringBuffer, you should consider the trade-off between synchronization and performance. Synchronization in StringBuffer comes at a cost: it introduces a slight overhead, making it slightly slower than StringBuilder. Therefore, if thread safety is not a concern in your specific scenario, it will be more efficient to use StringBuilder. It's worth noting that StringBuffer has been a part of Java since its initial release (Java $1.0$), while StringBuilder was introduced as a lightweight alternative in Java $5.0$, offering improved performance for non-thread-safe operations.

So, while both classes serve the purpose of creating and manipulating mutable sequences of characters and share similar methods, there is one crucial distinction: StringBuffer is thread-safe, which enables its usage by multiple threads without requiring external synchronization. On the other hand, StringBuilder is not thread-safe and should only be used by a single thread.

Let's see the price of synchronization paid in a real example:

const val N = 99999999 // Number of iterations for the test

fun main() {
    var time: Long
    var executionTime: Long

    println("For the same task:")

    // Using StringBuffer
    val buffer = StringBuffer()
    time = System.currentTimeMillis() // We save the start time of the task
    for (i in N downTo 1) {
        buffer.append("")
    }
    executionTime = System.currentTimeMillis() - time // We find the execution time of the task
                                                      // by subtracting the start time from the end time
    println("StringBuffer gets it finished in $executionTime ms,")

    // Using StringBuilder
    val builder = StringBuilder()
    time = System.currentTimeMillis()
    for (i in N downTo 1) {
        builder.append("")
    }
    executionTime = System.currentTimeMillis() - time
    println("while StringBuilder gets it finished in just $executionTime ms!")
}

The output of this code will look like this:

For the same task:
StringBuffer gets it finished in 1999 ms,
while StringBuilder gets it finished in just 193 ms!

In this example, we perform a test where both StringBuffer and StringBuilder are used to repeatedly append an empty string N times. We measure the execution time for each approach using the System.currentTimeMillis() method.

When you run this code, you will notice that StringBuilder performs significantly faster than StringBuffer, due to the overhead of synchronization of the latter. Please note that the actual execution times may vary based on the system and environment where the code is run.

Conclusion

When multiple threads try to access and modify the same StringBuilder object at the same time, they may cause data inconsistency or corruption. StringBuffer, on the other hand, is a synchronized and thread-safe version of StringBuilder. It ensures that only one thread can access and modify the string at a time, preventing any concurrency issues. However, this comes at a cost of performance and memory overhead. Therefore, you should use StringBuffer only when you need to share the string among multiple threads; otherwise, StringBuilder is a better option. Now it's time for you to buffer some practice.