StringBuffer in Java

String in Java
• String class represents character strings, we can instantiate String by two ways.
• String str = "abc"; or String str = new String ("abc");
• String is immutable in Java, so it’s easy to share it across different threads or
functions.
• When we create a String using double quotes, it first looks for the String with
the same value in the JVM string pool, if found it returns the reference else it
creates the String object and then places it in the String pool. This way JVM
saves a lot of space by using the same String in different threads. But if a new
operator is used, it explicitly creates a new String in the heap memory.
• + operator is overloaded for String and used to concatenate two Strings.
Although internally it uses StringBuffer to perform this action.
• String overrides equals() and hashCode() methods, two Strings are equal only if
they have the same characters in the same order. Note that equals() method is
case sensitive, so if you are not looking for case sensitive checks, you should use
equalsIgnoreCase() method.
• A String represents a string in the UTF-16 format
• String is a final class with all the fields as final except “private int hash”. This
field contains the hashCode() function value and created only when the
hashCode() method is called and then cached in this field. Furthermore, the
hash is generated using final fields of String class with some calculations, so
every time hashCode() method is called, it will result in the same output. For
the caller, it’s like calculations are happening every time but internally it’s
cached in the hash field.
StringBuffer class in Java
• StringBuffer is a peer class of String that provides
much of the functionality of strings. String
represents fixed-length, immutable character
sequences while StringBuffer represents growable
and writable character sequences.
• StringBuffer may have characters and substrings
inserted in the middle or appended to the end.
It will automatically grow to make room for such
additions and often has more characters
preallocated than are actually needed, to allow
room for growth.
 Compare String with StringBuffer class
Factors String StringBuffer
package Java.lang.String Java.lang.StringBufer
Class type Final Final
Modifiable Not allowed Allowed
Constructors String(); String(byte[] bytes); String(byte[] StringBuffer()
bytes, Charset charset); String(byte[] bytes, StringBuffer(String str)
int offset, int length) ;String(byte[] bytes,
int offset, int length, Charset charset);
StringBuffer(int capacity)
String(byte[] bytes, int offset, int length,
String charsetName); String(byte[] bytes,
String charsetName); String(char[] value);
String(char[] value, int offset, int count);
String(int[] codePoints, int offset, int
count); String(String original);
String(StringBuffer buffer)
Length of the Fixed once created Flexible length that can be modified
String in terms of both length and content.

Safe for Not a Safe Safe, methods are synchronized

multithreading
Reserved no Yes, upto 32 Bytes and possible
memory to modify.
StringBuffer Constructors
 StringBuffer append() in Java
Modifier and Type Method and Description

StringBuffer append(boolean b)
Appends the string representation of the boolean argument to the sequence.
StringBuffer append(char c)
Appends the string representation of the char argument to this sequence.
StringBuffer append(char[] str)
Appends the string representation of the char array argument to this sequence.
StringBuffer append(char[] str, int offset, int len)
Appends the string representation of a subarray of the char array argument to this sequence.
StringBuffer append(CharSequence s)
Appends the specified CharSequence to this sequence.
StringBuffer append(CharSequence s, int start, int end)
Appends a subsequence of the specified CharSequence to this sequence.
StringBuffer append(double d)
Appends the string representation of the double argument to this sequence.
StringBuffer append(float f)
Appends the string representation of the float argument to this sequence.
StringBuffer append(int i)
Appends the string representation of the int argument to this sequence.
StringBuffer append(long lng)
Appends the string representation of the long argument to this sequence.
StringBuffer append(Object obj)
Appends the string representation of the Object argument.
StringBuffer append(String str)
Appends the specified string to this character sequence.
StringBuffer append(StringBuffer sb)
Appends the specified StringBuffer to this sequence.
Example
public class Test
{
public static void main(String args[]) {
StringBuffer sb = new StringBuffer("Test");
sb.append(" String Buffer");
System.out.println(sb);
StringBuffer sb2 = new StringBuffer("pi = ");
sb2.append(3.14159f);
System.out.println(sb2); // output is "pi = 3.14159"

}
}
Output
Test String Buffer
pi = 3.14159
 StringBuffer appendCodePoint()
Modifier and Type Method and Description
StringBuffer appendCodePoint(int codePoint)
Appends the string representation of the codePoint argument to this sequence.
// Java praogram to illustrate the
// java.lang.StringBuffer.appendCodePoint(int cp)
import java.lang.*;
public class Geeks {
public static void main(String[] args)
{
StringBuffer sbf = new StringBuffer("Geeksforgeeks");
System.out.println("String buffer = " + sbf);
// Here it appends the CodePoint as String to the string buffer
sbf.appendCodePoint(65);
System.out.println("After appending CodePoint is = " + sbf);
}
}
Output:
String buffer = Geeksforgeeks
After appending CodePoint is = GeeksforgeeksA
 StringBuffer methods in Java
Modifier Method and Description
and Type
int capacity()
Returns the current capacity. The
capacity is the amount of storage available for newly
inserted characters, beyond which an allocation will occur.
char charAt(int index)
Returns the char value in this sequence at the specified index. The first char value is
at index 0, the next at index 1, and so on, as in array indexing.The index argument
must be greater than or equal to 0, and less than the length of this sequence.
If the char value specified by the index is a surrogate, the surrogate value is
returned.
int codePointAt(int index)
Returns the character (Unicode code point) at the specified index. The index refers
to char values (Unicode code units) and ranges from 0 to length() - 1.If
the char value specified at the given index is in the high-surrogate range, the
following index is less than the length of this sequence, and the char value at the
following index is in the low-surrogate range, then the supplementary code point
corresponding to this surrogate pair is returned. Otherwise, the char value at the
given index is returned.
 StringBuffer methods in Java
Modifier Method and Description
and Type
int codePointBefore(int index)
Returns the character (Unicode code point) before the specified index. The index
refers to char values (Unicode code units) and ranges from 1 to length().If
the char value at (index - 1) is in the low-surrogate range, (index - 2) is not
negative, and the char value at (index - 2) is in the high-surrogate range, then the
supplementary code point value of the surrogate pair is returned. If the char value
at index - 1 is an unpaired low-surrogate or a high-surrogate, the surrogate value is
returned.
int codePointCount(int beginIndex, int endIndex)
Returns the number of Unicode code points in the specified text range of this sequence.
import java.lang.*;
public class StringDemo {
public static void main(String[] args) {
String str = "JAVA";
System.out.println("String = " + str); // codepoint before index 1 i.e J
int retval = str.codePointBefore(1); // prints character before index1 in string
System.out.println("Character(unicode point) = " + retval);
}
}
String = JAVA
Character(unicode point) = 74
 Methods in StringBuffer class in Java
1) length( ) and capacity( ): The length of a StringBuffer can be
found by the length( ) method, while the total allocated
capacity can be found by the capacity( ) method.
Code Example:
import java.io.*;
class GFG {
public static void main(String[] args)
{
StringBuffer s = new StringBuffer(“JavaForSECS");
int p = s.length();
int q = s.capacity();
System.out.println("Length of string JavaForSECS =" + p);
System.out.println("Capacity of string JavaForSECS =" + q);
}
}

Output:
Length of string JavaForSECS=11
Capacity of string JavaForSECS=27
 StringBuffer append() in Java
Modifier and Type Method and Description

StringBuffer delete(int start, int end)

Removes the characters in a substring of this sequence. The substring
begins at the specified start and extends to the character at index end - 1 or
to the end of the sequence if no such character exists. If start is equal
to end, no changes are made.
StringBuffer deleteCharAt(int index)
Removes the char at the specified position in this sequence. This
sequence is shortened by one char.Note: If the character at the given
index is a supplementary character, this method does not remove the
entire character. If correct handling of supplementary characters is
required, determine the number of chars to remove by
callingCharacter.charCount(thisSequence.codePointAt(index)),
where thisSequence is this sequence.

StringBuffer sb = new StringBuffer("0123456789");

System.out.println(sb.delete(4,6)); // output is "01236789"
Example StringBuffer insert() in
Java
// Java program to demonstrate StringBuffer insert for boolean input.
import java.lang.*;
public class GFG {
public static void main(String[] args)
{
StringBuffer str = new StringBuffer("geeks for geeks");
System.out.println("string = " + str);
// insert boolean value at offset 8
str.insert(8, true);
// prints stringbuffer after insertion
System.out.print("After insertion = ");
System.out.println(str.toString());
}
}
string = geeks for geeks
After insertion = geeks fotruer geeks
 StringBuffer in Java
Modifier and Type Method and Description

void ensureCapacity(int minimumCapacity)

Ensures that the capacity is at least equal to the specified minimum. If the
current capacity is less than the argument, then a new internal array is
allocated with greater capacity. The new capacity is the larger of:
The minimumCapacity argument. Twice the old capacity, plus 2.
If the minimumCapacity argument is nonpositive, this method takes no
action and simply returns.
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
Characters are copied from this sequence into the destination character
array dst. The first character to be copied is at index srcBegin; the last
character to be copied is at index srcEnd-1. The total number of characters
to be copied is srcEnd-srcBegin. The characters are copied into the subarray
of dst starting at index dstBegin and ending at index:
dstbegin + (srcEnd-srcBegin) - 1
int indexOf(String str)
Returns the index within this string of the first occurrence of the specified substring.
int indexOf(String str, int fromIndex)
Returns the index within this string of the first occurrence of the specified substring,
starting at the specified index.
 StringBuffer append() in Java
Modifier and Type Method and Description

StringBuffer insert(int offset, boolean b)

Inserts the string representation of the boolean argument into this sequence.
StringBuffer insert(int offset, char c)
Inserts the string representation of the char argument into this sequence.
StringBuffer insert(int offset, char[] str)
Inserts the string representation of the char array argument into this sequence.
StringBuffer insert(int index, char[] str, int offset, int len)
Inserts the string representation of a subarray of the str array argument into this sequence.
StringBuffer insert(int dstOffset, CharSequence s)
Inserts the specified CharSequence into this sequence.
StringBuffer insert(int dstOffset, CharSequence s, int start, int end)
Inserts a subsequence of the specified CharSequence into this sequence.
StringBuffer insert(int offset, double d)
Inserts the string representation of the double argument into this sequence.
StringBuffer insert(int offset, float f)
Inserts the string representation of the float argument into this sequence.
StringBuffer insert(int offset, int i)
Inserts the string representation of the second int argument into this sequence.
StringBuffer insert(int offset, long l)
Inserts the string representation of the long argument into this sequence.
StringBuffer insert(int offset, Object obj)
Inserts the string representation of the Object argument into this character sequence.
 StringBuffer in Java
Modifier and Type Method and Description

int lastIndexOf(String str)

Returns the index within this string of the rightmost occurrence of the specified substring.
int lastIndexOf(String str, int fromIndex)
Returns the index within this string of the last occurrence of the specified substring.
class GFG {
public static void main(String[] args)
{
// create a StringBuffer object with a String pass as parameter
StringBuffer str = new StringBuffer("GeeksForGeeks");
// print string
System.out.println("String contains = " + str);
// get index of string For
int index = str.lastIndexOf("Geeks");
// print results
System.out.println("Index of last occurance“+ " string \"Geeks\"= “+index);
}
}
String contains = GeeksForGeeks
Index of last occurance string "Geeks"= 8
 StringBuffer in Java
Modifier and Type Method and Description

int length()
Returns the length (character count).
int offsetByCodePoints(int index, int codePointOffset)
Returns the index within this sequence that is offset from the
given index by codePointOffset code points.
StringBuffer replace(int start, int end, String str)
Replaces the characters in a substring of this sequence with characters in the
specified String.
StringBuffer reverse()
Causes this character sequence to be replaced by the reverse of the sequence.
If there are any surrogate pairs included in the sequence, these are treated as
single characters for the reverse operation. Thus, the order of the high-low
surrogates is never reversed. Let n be the character length of this character
sequence (not the length in char values) just prior to execution of
the reverse method. Then the character at index k in the new character
sequence is equal to the character at index n-k-1 in the old character
sequence.Note that the reverse operation may result in producing surrogate
pairs that were unpaired low-surrogates and high-surrogates before the
operation. For example, reversing "\uDC00\uD800" produces "\uD800\uDC00"
which is a valid surrogate pair.
 StringBuffer in Java
Modifier and Type Method and Description

void setCharAt(int index, char ch)

The character at the specified index is set to ch. This sequence is altered to
represent a new character sequence that is identical to the old character
sequence, except that it contains the character ch at position index.The index
argument must be greater than or equal to 0, and less than the length of this
sequence.
void setLength(int newLength)
Sets the length of the character sequence. The sequence is changed to a new
character sequence whose length is specified by the argument. For every
nonnegative index k less than newLength, the character at index k in the new
character sequence is the same as the character at index k in the old sequence
if k is less than the length of the old character sequence; otherwise, it is the
null character '\u0000'. In other words, if the newLength argument is less than the
current length, the length is changed to the specified length.If
the newLength argument is greater than or equal to the current length,
sufficient null characters ('\u0000') are appended so that length becomes
the newLength argument.
The newLength argument must be greater than or equal to 0.
 StringBuffer in Java
Modifier and Type Method and Description

CharSequence subSequence(int start, int end)

Returns a new character sequence that is a subsequence of this sequence.
String substring(int start)
Returns a new String that contains a subsequence of characters currently contained in this
character sequence.
String substring(int start, int end)
Returns a new String that contains a subsequence of characters currently contained in this
sequence.
String toString()
Returns a string representing the data in this sequence. A new String object is
allocated and initialized to contain the character sequence currently
represented by this object. This String is then returned. Subsequent changes to
this sequence do not affect the contents of the String.
void trimToSize()
Attempts to reduce storage used for the character sequence. If the buffer is
larger than necessary to hold its current sequence of characters, then it may
be resized to become more space efficient. Calling this method may, but is not
required to, affect the value returned by a subsequent call to
the capacity() method.
int number = 23;
String str = String.valueOf(number);
System.out.println(str+99); //output is 2399
StringBuffer sb = new StringBuffer("0123456789");
System.out.println(sb.delete(4,6)); // output is "01236789"
int number = 23;
String str = String.valueOf(number);
System.out.println(str+99); //output is 2399
StringBuffer s = new StringBuffer("A man a plan a canal Panama");
sb.reverse();
System.out.println(sb); // output: "amanaP lanac a nalp a nam A"
StringBuffer sb = new StringBuffer("This is a test.");
sb.replace(5, 7, "was");
System.out.println("After replace: " + sb);
//output is "After replace: This was a test"
StringBuffer sb = new StringBuffer("Hello");
System.out.println("buffer before = " + sb);//output is "buffer before =
Hello"
sb.setCharAt(1, 'i');
sb.setLength(2);
System.out.println("buffer after = " + sb);//output is "buffer after = Hi"
StringBuffer sb = new StringBuffer("test string");
System.out.println( sb.toString() ); // output is "test string"
StringBuffer s = new StringBuffer("GeeksforGeeks");
s.replace(5, 8, "are");
System.out.println(s); // returns GeeksareGeeks
StringBuffer str= new StringBuffer("WelcomeGeeks");
System.out.println("SubSequence = "+ str.substring(5));
//Output: SubSequence = meGeeks
str.setLength(10);
System.out.println("After setLength() String = "+ str.toString());
//Output: After setLength() String = WelcomeGee