StringBuffer Class in Java

StringBuffer Class in Java

`StringBuffer` is a class in Java that represents a mutable sequence of characters. Unlike the `String` class, which is immutable, a `StringBuffer` allows for the modification of its content without creating a new object. This makes it more efficient for situations where frequent modifications to a sequence of characters are required.

Key Features:

1. Mutability:

   - `StringBuffer` objects are mutable, meaning the content of a `StringBuffer` instance can be modified after its creation.

2. Synchronization:

   - `StringBuffer` is synchronized, making it thread-safe. This ensures that multiple threads can safely access and modify a `StringBuffer` object without interference.

3. Performance Considerations:

   - While `StringBuffer` provides mutability, it might have performance overhead due to synchronization. If thread safety is not required, the non-synchronized class `StringBuilder` should be considered for better performance.

Common Methods:

Here are some commonly used methods of the `StringBuffer` class:

1. Constructor:

- `StringBuffer()`

  - Creates an empty `StringBuffer` with the default initial capacity (16 characters).

• StringBuffer buffer = new StringBuffer();

2. Appending Content:

- `append(String str)`

  - Appends the specified string to the end of the `StringBuffer`.

buffer.append("Hello");

buffer.append(" World");

3. Inserting Content:

- `insert(int offset, String str)`

  - Inserts the specified string at the specified offset.

• buffer.insert(5, " Java");

 4. Deleting Content:

- `delete(int start, int end)`

  - Deletes the characters between the specified `start` (inclusive) and `end` (exclusive) indices.

buffer.delete(6, 11);

5. Reversing Content:

- `reverse()`

  - Reverses the characters in the `StringBuffer`.

• buffer.reverse();

6. Capacity Management:

- `capacity()`

  - Returns the current capacity of the `StringBuffer`.

• int capacity = buffer.capacity();

- `ensureCapacity(int minCapacity)`

  - Ensures that the capacity of the `StringBuffer` is at least equal to the specified minimum capacity.

• buffer.ensureCapacity(50);

7. Converting to String:

- `toString()`

  - Converts the `StringBuffer` to a `String`.

• String result = buffer.toString();

 Example Usage:

// Creating a StringBuffer

StringBuffer buffer = new StringBuffer();

// Appending content

buffer.append("Hello");

buffer.append(" World");

// Inserting content

buffer.insert(5, " Java");

// Deleting content

buffer.delete(6, 11);

// Reversing content

buffer.reverse();

// Converting to String

String result = buffer.toString();

The `StringBuffer` class provides a flexible and thread-safe way to work with mutable character sequences in Java. If synchronization is not required, consider using the `StringBuilder` class for potentially better performance.