StringBuilder Method in Java - All Methods and Examples

In Java, the StringBuilder class is a handy tool for working with strings that change often. Unlike the String class, which creates a new object each time you change a string, StringBuilder lets you modify the string directly. This makes it faster and saves memory. It is especially useful when you need to make many changes to strings when dealing with large amounts of text. This article explains how to use key methods as well as shows why the StringBuilder method in Java is a better choice for tasks that need fast and efficient string handling.

Understanding the StringBuilder Class in Java

The StringBuilder method in Java is part of the java.lang package and allows you to work with a changeable sequence of characters. Unlike the String class, which creates new objects every time you modify a string. StringBuilder lets you change the string directly, which saves time and memory. It provides methods like append(), insert(), delete(), and replace() to easily add, remove, or change characters. As well as this makes it a great choice for tasks where you need to make many changes to a string quickly. Such as in loops or when handling large amounts of text.

Common Methods in StringBuilder Class

Here is a look at some of the key methods provided by the StringBuilder class:

1. append()

The append() method in StringBuilder lets you add new data, like text or numbers, to the end of the current string. You can use it with different types of data, such as strings, integers, and characters.

Example:

StringBuilder sb = new StringBuilder("Hello");
sb.append(" World");
System.out.println(sb.toString()); // Output: Hello World        

2. insert()

The insert() StringBuilder method in Java adds data at a specific spot in the StringBuilder string.

Example:

StringBuilder sb = new StringBuilder("Hello World");
sb.insert(6, "Java ");
System.out.println(sb.toString()); // Output: Hello Java World        

3. delete()

The delete() java StringBuilder class removes characters from the StringBuilder object between the specified start and end indices.

Example:

StringBuilder sb = new StringBuilder("Hello Java World");
sb.delete(5, 10);
System.out.println(sb.toString()); // Output: Hello World        

4. replace()

The replace() method replaces characters in the StringBuilder object from the specified start index to the end index with a new string.

Example:

StringBuilder sb = new StringBuilder("Hello World");
sb.replace(6, 11, "Java");
System.out.println(sb.toString()); // Output: Hello Java        

5. reverse()

The reverse() reverses the order of characters in the StringBuilder method in Java.

Example:

StringBuilder sb = new StringBuilder("Hello World");
sb.reverse();
System.out.println(sb.toString()); // Output: dlroW olleH        

6. substring()

substring() StringBuilder java methods extract a substring from the StringBuilder object from the specified start index to the end index.

Example:

StringBuilder sb = new StringBuilder("Hello World");
String sub = sb.substring(6, 11);
System.out.println(sub); // Output: World        

7. capacity()

The capacity() method returns the current capacity of the StringBuilder object, which is the length of the character array used to store the characters.

Example:

StringBuilder sb = new StringBuilder("Hello");
System.out.println(sb.capacity()); // Output: 16 (initial capacity may vary)        

8. length()

The length() method returns the number of characters currently stored in the StringBuilder object.

Example:

StringBuilder sb = new StringBuilder("Hello World");
System.out.println(sb.length()); // Output: 11        

If you want to learn more about the StringBuilder method in Java then you can consider enrolling in a Java full stack course certification. It will teach you all about methods as well as beneficial for starting your career in the field of software development.

Java StringBuilder Performance

It is faster than String when you need to make many changes. Because it doesn’t create a new object each time. This makes it better for situations where you change strings often.

For example, if you are adding many strings together in a loop, StringBuilder is better. Because it avoids the extra work of creating and cleaning up new string objects, making the process faster.

Java StringBuilder Example

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append("Number ").append(i).append("\n");
}
System.out.println(sb.toString());        

In this example, using StringBuilder to build a large string in a loop is more efficient than using String concatenation.

Conclusion

In conclusion, the StringBuilder class in Java is great for efficiently handling strings that change often. Unlike String, which creates a new object every time you modify it. It also allows direct changes to the existing string, which saves time and memory. It has handy methods to easily update strings. The StringBuilder method in Java works best when you need to make many changes, such as in loops or with large text, because it avoids extra work and runs faster. For tasks that involve a lot of string changes, StringBuilder is the better choice for better performance and less memory use.