StringBuilder in Java
StringBuilder in Java
Java StringBuilder class is introduced since JDK 1.5. The StringBuilder class is mainly used to create modifiable or mutable strings. Note that the StringBuilder class is not synchronized. The methods of the StringBuilder class are very much identical to the methods of the StringBuffer class.
Java StringBuilder Constructor
The StringBuilder class provides the following constructors:
1) StringBuilder(): The default constructor creates an empty StringBuilder and provides the initial capacity for 16 characters.
2) StringBuilder(int capacity): The parameterized constructor creates an empty StringBuilder and provides the capacity specified in the argument.
3)StringBuilder(CharSequence sequence): Another parametrized constructor that builds a non-empty String builder using the character sequence mentioned in the argument.
4) StringBuilder(String st): Another parametrized constructor that makes a non-empty String Builder using the content provided in the argument.
The following code uses the above-mentioned constructors to create objects of the StringBuilder class.
FileName: StringBuilderExample.java
// A Java program to demonstrate StringBuilder
import java.util.*;
public class StringBufferExample
{
// main method
public static void main(String argvs[]) throws Exception
{
// build a StringBuilder object
// using the parameterless constructor
StringBuilder st = new StringBuilder();
st.append("Tutorial & Example");
// display string on the console
System.out.println("The First String = " + st.toString() );
// building a StringBuilder object
// using the StringBuilder(Charseq) constructor
StringBuilder st1 = new StringBuilder("AAABBCC");
// display string on the console
System.out.println("The Second String = " + st1.toString() );
// building a StringBuilder object
// using the StringBuilder(capacity) constructor
StringBuilder st2 = new StringBuilder(11);
// display string on the console
System.out.println("The capacity of the String Builder is = " + st2.capacity());
String s = "ABC";
// build a StringBuilder object
// using the StringBuilder(String) constructor
StringBuilder st3 = new StringBuilder(s);
// display string on the console
System.out.println("The Third String = " + s.toString());
}
}
Output:
The First String = Tutorial & Example The Second String = AAABBCC The capacity of the String Builder is = 11 The Third String = ABC
Explanation: After creating different objects of the StringBuilder class, the toString() method is invoked on the objects to return the string, which represents the data contained in the String Builder object.
Java StringBuilder Class Methods
The StringBuilder class has a lot of inbuilt methods. A few of them are mentioned below.
| Method Name | Description |
| public StringBuilder append(String str) | Used to add string str at the end of the string on which the append() method is called. The append() method is overloaded with primitive data types like append(int), append(float), etc. |
| public StringBuilder replace(int start, int end, String s) | Replaces the specified string from index start to index end using the string s. |
| public StringBuilder delete(int start, int end) | Modifies the specified string by deleting its characters from the start index to the end index. |
| public int capacity() | Returns the capacity |
| public char charAt(int idx) | Whatever character is present at the index idx gets returned upon the invocation of this method. |
| public String substring(int i) | Returns a substring of the specified string that starts from the index i |
| public String substring(int start, int end) | Returns a substring of the specified string that starts from the index start and goes till the end index. |
| public StringBuilder reverse() | Manipulates the specified string by reversing it |
| public void ensureCapacity(int minCapacity) | Ensures that capacity is at least equal to the argument minCapacity |
| public StringBuilder delete(int start, int end) | Modifies the specified string by deleting characters from the start index to end index |
| public StringBuilder insert(int offset, String str) | Inserts the string str in the specified string at the particular location by using the help of offset. The overloaded version of the method also exists for primitive data types. |
| public void setCharAt(int i, char c) | Modifies the given string by replacing the character at the index i with character c. |
Let’s use the StringBuilder class methods in Java program.
The insert() method
FileName: StringBuilderMethodsExample.java
public class StringBuilderMethodsExample
{
// main method
public static void main(String argvs[])
{
// creating an object of the String Builder class
StringBuilder sb = new StringBuilder("Hello World ");
System.out.println("String before the insert method is invoked - " + sb);
sb.insert(0,"New Java "); // inserting the string “New Java” at the index 0
System.out.println(); // new line
System.out.println("String after the insert method is invoked - " + sb);
}
}
Output:
String before the insert method is invoked - Hello World String after the insert method is invoked - New Java Hello World
Explanation: It is evident that, when the insert() method inserts the specified string at any specified index, the characters present at, and after that index gets shifted to make space for the string to be inserted.
The charAt() method
FileName: StringBuilderMethodsExample1.java
public class StringBuilderMethodsExample1
{
// main method
public static void main(String argvs[])
{
// creating an object of the String Builder class
StringBuilder sb = new StringBuilder("Hello World ");
int i = 7; // i represents index
// ch stores the character present at index i
char ch = sb.charAt(i);
// displaying the character present at the index i
System.out.println("Character present at the index " + i + " is " + ch);
}
}
Output:
Character present at the index 7 is o
Explanation: In the above program, the variable ch stores the character present at the index i.
The replace() method
FileName: StringBuilderMethodsExample2.java
public class StringBuilderMethodsExample2
{
// main method
public static void main(String argvs[])
{
// creating an object of the String Builder class
StringBuilder sb = new StringBuilder("Hello World ");
System.out.println("The given string is " + sb);
// starting and ending index
int start = 8;
int end = 10;
// string that does the replacement
String str = "ooo";
// invoking the replace() method
StringBuilder newSb = sb.replace(start, end, str);
System.out.println(); // new line
System.out.println("The updated string is " + newSb);
}
}
Output:
The given string is Hello World The updated string is Hello Wooood
Explanation: The replace() method considers the indices just before the end index, starting from the start index. Thus, as per the above program, the replace() method considers indices from 8 to (10 – 1), i.e., 8 to 9. Thus, characters ‘r’ and ‘l’ are omitted, and the output confirms the same.
The delete() method
FileName: StringBuilderMethodsExample3.java
public class StringBuilderMethodsExample3
{
// main method
public static void main(String argvs[])
{
// creating an object of the String Builder class
StringBuilder sb = new StringBuilder("Hello World ");
System.out.println("The given string is " + sb);
// starting and ending index
int startIndex = 8;
int endIndex = 10;
// invoking the delete() method
StringBuilder newSb = sb.delete(startIndex, endIndex);
System.out.println(); // new line
System.out.println("The updated string is " + newSb);
}
}
Output:
The given string is Hello World The updated string is Hello Wod
Explanation: Similar to the replace() method, the delete() method considers the index, which is just before the specified ending index, as its last index (endIndex – 1 in our case). The start index is startIndex. Hence, characters ‘r’ and ‘l’ get omitted, which is evident by looking at the output.
The reverse() method
FileName: StringBuilderMethodsExample4.java
public class StringBuilderMethodsExample4
{
// main method
public static void main(String argvs[])
{
// creating an object of the String Builder class
StringBuilder sb = new StringBuilder("Hello World ");
System.out.println("The given string is " + sb);
// invoking the reverse() method
StringBuilder newSb = sb.reverse();
System.out.println(); // new line
System.out.println("The updated string is " + newSb);
}
}
Output:
The given string is Hello World The updated string is dlroW olleH
Explanation: In the program, the variable newSb stores the reversed string that is getting displayed in the output. The reverse() method comes in handy when one wants to check for palindromic strings.
The substring() method - I
FileName: StringBuilderMethodsExample5.java
public class StringBuilderMethodsExample5
{
// main method
public static void main(String argvs[])
{
// creating an object of the String Builder class
StringBuilder sb = new StringBuilder("Hello World ");
System.out.println("The given string is " + sb);
int index = 6;
// invoking the substring() method
String newSb = sb.substring(index);
System.out.println(); // new line
System.out.println("The substring starting from index " + index + " is " + newSb);
}
}
Output:
The given string is Hello World The substring starting from index 6 is World
Explanation: In the above program, we have only specified the starting index of the substring. The last index of the substring automatically becomes the last index of the given string.
The substring() method - II
FileName: StringBuilderMethodsExample6.java
public class StringBuilderMethodsExample6
{
// main method
public static void main(String argvs[])
{
// creating an object of the String Builder class
StringBuilder sb = new StringBuilder("Hello World ");
System.out.println("The given string is " + sb);
int startIndex = 6;
int endIndex = 9;
// invoking the substring() method
String newSb = sb.substring(startIndex, endIndex);
System.out.println(); // new line
System.out.println("The substring starting from index " + startIndex + " and ending at " + endIndex + " is " + newSb);
}
}
Output:
The given string is Hello World The substring starting from index 6 and ending at 9 is Wor
Explanation: The substring() method used in the above program is another version that requires the ending index too. Thus, whatever is present between the starting and ending index gets printed on the console.
The capacity() method
FileName: StringBuilderMethodsExample7.java
public class StringBuilderMethodsExample7
{
// main method
public static void main(String argvs[])
{
// creating an object of the String Builder class
StringBuilder sb = new StringBuilder( );
// invoking the method capacity
int capacity = sb.capacity();
System.out.println("The current capacity is: " + capacity);
}
}
Output:
The current capacity is: 16
Explanation: In the program, the parameterless constructor is invoked. Therefore, the capacity is 16.
The ensureCapacity() method
FileName: StringBuilderMethodsExample8.java
public class StringBuilderMethodsExample8
{
// main method
public static void main(String argvs[])
{
// creating an object of the String Builder class
StringBuilder sb = new StringBuilder( );
int minCapacity = 50;
// invoking the method ensureCapacity(), with minCapacity as its argument
sb.ensureCapacity(minCapacity);
// invoking the method capacity
int capacity = sb.capacity();
System.out.println("The current capacity is: " + capacity);
}
}
Output:
The current capacity is: 50
Explanation: In the above program, the ensureCapacity() method takes minCapacity in its argument. Therefore, the current capacity has to be greater than or equal to the value fetched by the variable minCapacity.
The setCharAt() method
FileName: StringBuilderMethodsExample9.java
public class StringBuilderMethodsExample9
{
// main method
public static void main(String argvs[])
{
// creating an object of the String Builder class
StringBuilder sb = new StringBuilder("Hello World" );
// specifies the index at which
// updation is going to take place
int index = 7;
// the new character to be inserted
char newChar = 'r';
// invoking the setCharAt() method
sb.setCharAt(index, newChar);
System.out.println("The current string is: " + sb);
}
}
Output:
The current string is: Hello Wrrld
Explanation: The setCharAt() method replaces the character present at the specified with the character provided by the user in its argument. In the above program, the character ‘o’ of the word ‘World’ is getting replaced by the character ‘r’.