> For the complete documentation index, see [llms.txt](https://www.pranaypourkar.co.in/the-programmers-guide/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://www.pranaypourkar.co.in/the-programmers-guide/java/java-basics/java-data-types/non-primitive-reference-types/string/stringbuilder.md). # StringBuilder ## Description `StringBuilder` was introduced in Java 5. It is similar to `StringBuffer`, but it is not synchronized, which means it is not thread-safe. This lack of synchronization makes `StringBuilder` generally faster than `StringBuffer` but not suitable for concurrent use in multithreaded environments. `StringBuilder` class in Java are mutable and designed for string manipulation. They provide methods to modify the contents of the string without creating new string objects, which can lead to better performance compared to using regular `String` objects for string manipulation. ```java StringBuilder sb = new StringBuilder("Hello"); sb.append(" World"); String result = sb.toString(); // result is "Hello World" ``` ## Methods Available in StringBuilder


Method	Description	Example	Output
`append(String s)`	Adds `s` at the end of the current `StringBuilder`	`sb.append("Hello")`	`"Hello"`
`insert(int offset, String s)`	Inserts `s` at the given index `offset`	`sb.insert(1, "abc")` (on `"xyz"`)	`"xabcyz"`
`replace(int start, int end, String s)`	Replaces characters between `start` and `end` with `s`	`sb.replace(1, 3, "abc")` (on `"xyz"`)	`"xabcz"`
`delete(int start, int end)`	Removes characters between `start` and `end`	`sb.delete(1, 3)` (on `"Hello"`)	`"Ho"`
`deleteCharAt(int index)`	Removes the character at `index`	`sb.deleteCharAt(2)` (on `"Hello"`)	`"Helo"`
`reverse()`	Reverses the `StringBuilder` content	`sb.reverse()` (on `"abc"`)	`"cba"`
`length()`	Returns the number of characters in `StringBuilder`	`sb.length()` (on `"Hello"`)	`5`
`charAt(int index)`	Returns the character at `index`	`sb.charAt(1)` (on `"Hello"`)	`'e'`
`setCharAt(int index, char ch)`	Modifies the character at `index`	`sb.setCharAt(1, 'A')` (on `"Hello"`)	`"HAllo"`
`substring(int start)`	Returns substring from `start` to end	`sb.substring(1)` (on `"Hello"`)	`"ello"`
`substring(int start, int end)`	Returns substring from `start` to `end-1`	`sb.substring(1, 3)` (on `"Hello"`)	`"el"`
`toString()`	Converts `StringBuilder` to a `String`	`sb.toString()` (on `"Hello"`)	`"Hello"`
`capacity()`	Returns current capacity of `StringBuilder`	`sb.capacity()`	`Default: 16, expands dynamically`
`ensureCapacity(int minCapacity)`	Ensures at least `minCapacity`, expanding if needed	`sb.ensureCapacity(50)`	`Capacity grows if < 50`
`trimToSize()`	Reduces the capacity to match the length	`sb.trimToSize()`	`Capacity reduces`

## Internal Working Internally it uses a resizable array to store the characters of the string. When we append or modify the contents of the string using methods like `append()`, `insert()`, `delete()`, etc., they directly modify the internal character array of the object without creating new string objects. This allows for efficient string manipulation, especially when dealing with large strings or performing many concatenation operations.

## Not Using String Pool Unlike regular `String` objects, `StringBuilder` do not use the string pool for storing string literals. When we create a `StringBuilder` object and append or modify its contents, new character arrays may be created dynamically to accommodate the changes, but these arrays are not stored in the string pool. This behavior is different from regular `String` objects, which may use the string pool for storing string literals to optimize memory usage. ## Using `String` (Concatenation) vs Using `StringBuilder` ### Issue with using `String` ```java String joinWords(String[] words) { String sentence = ""; // Starts with an empty string for (String w: words) { sentence = sentence + w; // Creates a new String object in every iteration } return sentence; } ``` **What's happening internally?** * Since **`String` is immutable**, `sentence = sentence + w;` creates a **new `String` object** each time. * Suppose we have `n` words, the number of `String` objects created will be **O(n)**. * But since Java needs to copy the previous string content **each time**, the **total character copies performed** sum up to **O(n²)**. ### **Why `StringBuilder` is Better?** ```java String joinWords(String[] words) { StringBuilder sentence = new StringBuilder(); // Mutable, resizable buffer for (String w: words) { sentence.append(w); // Efficiently appends to the same object } return sentence.toString(); } ``` **How `StringBuilder` improves performance** * `StringBuilder` uses an **internal character array** and grows dynamically. * Instead of **creating new objects**, it **modifies the same array**. * **Appending is O(1) amortized**, so the **total complexity is O(n)** instead of **O(n²)**. --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://www.pranaypourkar.co.in/the-programmers-guide/java/java-basics/java-data-types/non-primitive-reference-types/string/stringbuilder.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.