A string in Java is a sequence of characters stored using UTF-16 encoding, where every character occupies 16 bits.

In
Java, strings are immutable, meaning once created, their content cannot be changed once created.

Creating a String in Java

There are four ways to create a string in Java:

1. Using Character Array / ArrayList - Strings can be created by initializing a character array. For example:

char[] arr = ['g', 'e', 'e', 'k', 's'];

Here, each character of the string is stored in an array format.

2. Using the String Class - The String class creates immutable strings. Once a string is created, its content cannot be
modified. Operations like concatenation or changing the case of a string will create a new string object.

 String literal

String s = “GeeksforGeeks”;

A literal creates a string in the String Pool.

 Using new keyword

String s = new String (“GeeksforGeeks”);

This explicitly creates a new string object in the heap memory.

3. StringBuffer Class - The StringBuffer class creates mutable strings and is thread-safe. It is suitable for
multithreaded environments where multiple threads might access the same string object.

StringBuffer s = new StringBuffer("GeeksforGeeks");

With StringBuffer, you can append, insert, or modify the string.

4. StringBuilder Class - The StringBuilder class is similar to StringBuffer but is not thread-safe. It is used in single-
threaded environments to avoid the performance overhead of synchronization.

StringBuilder s = new StringBuilder("GeeksforGeeks");

Examples and Methods

Here, we explore some key methods provided by the String class in Java along with examples.

 length() : This method returns the number of characters in the string.

 charAt() : The charAt() method returns the character at a specified index. Index starts from 0 (like arrays).

 str.substring(start): Returns the substring from the start index to the end of the string.

 str.substring(start, end) : Returns the substring from the start index to the end - 1 index.

Example:

import java.io.*;

class GFG {

public static void main (String[] args) {

String str = "Geeks";

System.out.println(str.length());

System.out.println(str.charAt(3));
 System.out.println(str.substring(2));

System.out.println(str.substring(2, 4));

Output

eks

ek

Create String Objects using String literals

When strings are created using literals, Java optimizes memory usage by storing them in a String Pool. If two string
literals have the same content, they share the same memory location in the pool. However, when strings are created
using the new keyword, they are stored in the heap memory, and each object gets a separate memory allocation,
even if they have the same content.

import java.io.*;

class GFG {

public static void main (String[] args) {

// String creation using literals

String s1 = "geek";

String s2 = "geek";

// Comparing string literals

if (s1 == s2)

System.out.println("Yes");

else

System.out.println("No");

// String creation using the new keyword

String s3 = new String("geek");

// Comparing literal with object created using 'new'

if (s1 == s3)

System.out.println("Yes");
 else

System.out.println("No");

Output

Yes

No

More functions on the String Class

contains() Method : The contains() method checks if a specific sequence of characters exists within a string. It
returns true if the sequence is found, otherwise false.

import java.io.*;

class GFG {

public static void main (String[] args) {

String s1 = "geeksforgeeks";

String s2 = "geeks";

// Check if s1 contains s2

System.out.println(s1.contains(s2));

Output

true

equals() Method : The equals() method compares two strings for equality based on their content. It is case-sensitive.

import java.io.*;

class GFG {

public static void main (String[] args) {

String s1 = "GeeksforGeeks";

String s2 = "GeeksforGeeks";

// Compare s1 and s2 for equality

 System.out.println(s1.equals(s2));

Output

true

compareTo() Method : The compareTo() method compares two strings lexicographically:

 Returns 0 if both strings are equal.

 Returns a positive value if the first string is lexicographically greater.

 Returns a negative value if the first string is lexicographically smaller.

import java.io.*;

class GFG {

public static void main (String[] args) {

String s1 = "geeksforgeeks";

String s2 = "for";

// Compare s1 and s2

int res = s1.compareTo(s2);

if (res == 0)

System.out.println("Same");

else if (res > 0)

System.out.println("s1 Greater");

else

System.out.println("s1 Smaller");

Output

s1 Greater
indexOf() Method : The indexOf() method returns the starting index of the first occurrence of a specified substring
within the string. If the substring is not found, it returns -1.

import java.io.*;

class GFG {
 public static void main (String[] args) {

String s1 = "geeksforgeeks";

String s2 = "geek";

// Find the starting index of s2 in s1

System.out.println(s1.indexOf(s2));

}
Output

0
String Concatenation : String concatenation is the process of joining two or more strings to form a single combined
string. In Java, there are multiple ways to achieve string concatenation, including using the + operator and
the concat() method.

import java.io.*;

class GFG {

public static void main (String[] args) {

String s1 = "geeks";

// s2 references the same object as s1

String s2 = s1;

// Concatenating "forgeeks" to s1

s1 = s1 + "forgeeks"; // OR s1 = s1.concat("forgeeks");

System.out.println(s1);

System.out.println(s1 == s2);

Output

geeksforgeeks

false

String Methods in Java

String Methods

1. int length(): Returns the number of characters in the String.

"GeeksforGeeks".length(); // returns 13
2. Char charAt(int i): Returns the character at ith index.

"GeeksforGeeks".charAt(3); // returns ‘k’

3. String substring (int i): Return the substring from the ith index character to end.

"GeeksforGeeks".substring(3); // returns “ksforGeeks”

4. String substring (int i, int j): Returns the substring from i to j-1 index.

"GeeksforGeeks".substring(2, 5); // returns “eks”

5. String concat( String str): Concatenates specified string to the end of this string.

String s1 = ”Geeks”;

String s2 = ”forGeeks”;

String output = s1.concat(s2); // returns “GeeksforGeeks”

6. int indexOf (String s): Returns the index within the string of the first occurrence of the specified string.

String s = ”Learn Share Learn”;

int output = s.indexOf(“Share”); // returns 6

7. int indexOf (String s, int i): Returns the index within the string of the first occurrence of the specified string,
starting at the specified index.

String s = ”Learn Share Learn”;

int output = s.indexOf("ea",3);// returns 13

8. Int lastIndexOf( String s): Returns the index within the string of the last occurrence of the specified string.

String s = ”Learn Share Learn”;

int output = s.lastIndexOf("a"); // returns 14

9. boolean equals( Object otherObj): Compares this string to the specified object.

Boolean out = “Geeks”.equals(“Geeks”); // returns true

Boolean out = “Geeks”.equals(“geeks”); // returns false

10. boolean equalsIgnoreCase (String anotherString): Compares string to another string, ignoring case
considerations.

Boolean out= “Geeks”.equalsIgnoreCase(“Geeks”); // returns true

Boolean out = “Geeks”.equalsIgnoreCase(“geeks”); // returns true

11. int compareTo( String anotherString): Compares two string lexicographically.

int out = s1.compareTo(s2); // where s1 ans s2 are

// strings to be compared

This returns difference s1-s2. If :

out < 0 // s1 comes before s2

out = 0 // s1 and s2 are equal.

out > 0 // s1 comes after s2.

12. int compareToIgnoreCase( String anotherString): Compares two string lexicographically, ignoring case
considerations.

int out = s1.compareToIgnoreCase(s2);

// where s1 ans s2 are

// strings to be compared

This returns difference s1-s2. If :

out < 0 // s1 comes before s2

out = 0 // s1 and s2 are equal.

out > 0 // s1 comes after s2.

 Note- In this case, it will not consider case of a letter (it will ignore whether it is uppercase or lowercase).

13. String toLowerCase(): Converts all the characters in the String to lower case.

String word1 = “HeLLo”;

String word3 = word1.toLowerCase(); // returns “hello"

14. String toUpperCase(): Converts all the characters in the String to upper case.

String word1 = “HeLLo”;

String word2 = word1.toUpperCase(); // returns “HELLO”

15. String trim(): Returns the copy of the String, by removing whitespaces at both ends. It does not affect
whitespaces in the middle.

String word1 = “ Learn Share Learn “;

String word2 = word1.trim(); // returns “Learn Share Learn”

16. String replace (char oldChar, char newChar): Returns new string by replacing all occurrences
of oldChar with newChar.

String s1 = “feeksforfeeks“;

String s2 = “feeksforfeeks”.replace(‘f’ ,’g’); // returns “geeksgorgeeks”

 Note:- s1 is still feeksforfeeks and s2 is geeksgorgeek

StringBuilder and StringBuffer

StringBuilder: StringBuilder is a class in Java that represents a mutable sequence of characters. Unlike the String
class, which creates immutable sequences, StringBuilder allows modification of its contents without creating new
objects. It is specifically designed for use in single-threaded environments, as it does not provide thread safety.
StringBuilder is a faster alternative to StringBuffer when thread synchronization is not required. Its functions are very
similar to those of the StringBuffer class, making it a straightforward option for mutable string manipulation.

 Use StringBuilder in single-threaded environments for faster performance.

 Ideal for applications where thread safety is not a concern.

StringBuffer: StringBuffer is a class in Java that also represents a mutable sequence of characters. However, unlike
StringBuilder, it provides thread safety by ensuring synchronization. This makes StringBuffer a suitable choice for
multi-threaded environments where multiple threads may access or modify the string concurrently. Although it has
slightly more overhead than StringBuilder due to synchronization, it ensures reliable operation in concurrent
scenarios. StringBuffer is often used when both mutability and thread safety are essential.

Difference Between StringBuilder and StringBuffer

Feature StringBuilder StringBuffer

Thread Safety Not thread-safe. Thread-safe.

Synchronization Does not provide synchronization. Provides synchronization.

Faster, as it doesn't have overhead for thread Slower due to synchronization

Performance
safety. overhead.

Use Case Single-threaded environment. Multi-threaded environment.

Recommendatio
Preferred for single-threaded programs. Used when thread safety is required.
n

Here is the Example for the StringBuilder and StringBuffer Classes:

// Java code to illustrate the internal

// working of String, StringBuilder

// and StringBuffer class

class GfG

public static void main (String[] args) {

String s1 = "geeks";

String s2 = s1;

// Creates a new location to store s1

s1 = s1 + "forgeeks";

// s1 and s2 refers to different location

if(s1 == s2)

System.out.println("Same");

else

System.out.println("Not Same");

// StringBuilder or StringBuffer class

StringBuilder sb1 = new StringBuilder("geeks");

 // sb2 refers to the same location as sb1

StringBuilder sb2 = sb1;

// Append operation modifies the same object

// as it is mutable in nature

sb1 = sb1.append("forgeeks");

// Both sb1 and sb2 refers to the same location

if(sb1 == sb2)

System.out.println("Same");

else

System.out.println("Not Same");

Output

Not Same

Same

StringBuilder and StringBuffer Methods

Common Methods in String, StringBuilder, and StringBuffer Classes:

1. length():
The length() method is used to determine the number of characters in a sequence. It returns the length of
the sequence represented by the object. For example, if you call length() on a StringBuilder object, it will
return the number of characters currently stored in it.

2. charAt(index):
This method is used to fetch the character present at a specific index in the sequence. The index should be
between 0 and length()-1. For instance, if the string is "Geeks", charAt(1) will return 'e'.

3. indexOf(str):
The indexOf() method searches for the first occurrence of a specified substring within the sequence. If the
substring exists, the method returns the index of its first occurrence; otherwise, it returns -1.

4. indexOf(str, fromIndex):
This is a variation of the indexOf() method, which starts searching for the substring from a specified index. If
the substring is found, it returns the index of the first occurrence; otherwise, it returns -1.
 5. lastIndexOf(str):
This method searches for the last occurrence of a specified substring within the sequence. If the substring
exists, it returns the index of its last occurrence; otherwise, it returns -1.

6. lastIndexOf(str, fromIndex):
Similar to lastIndexOf(str), this method begins the search from the specified fromIndex and moves backward
to find the last occurrence of the substring.

7. compareTo(sb):
The compareTo() method compares two sequences lexicographically. It returns 0 if the sequences are equal,
a positive value if the current sequence is greater, and a negative value if it is smaller.

8. substring(beginIndex):
This method returns a new sequence starting from the specified beginIndex to the end of the sequence.

9. substring(beginIndex, endIndex):
This variation of substring() allows you to specify both the starting and ending indices. It returns a new
sequence starting at beginIndex and ending at endIndex - 1.

10. chars():
The chars() method provides a stream of integer values representing the characters in the sequence.

Methods Exclusive to StringBuilder and StringBuffer Classes:

1. append(x):
The append() method adds the specified data to the end of the sequence. This data can be of various types,
such as boolean, int, char, String, float, or Object. For example, you can append "World" to "Hello"
using append().

2. insert(offset, x):
This method allows you to insert data at a specified offset position in the sequence. For instance, you can
insert "Java" at index 4 in the string "GeeksFor" to make it "GeeksJavaFor".

3. setCharAt(index, c):
The setCharAt() method modifies the character at the specified index in the sequence. For example, you can
change the first character of "Geeks" to 'T', resulting in "Teeks".

4. reverse():
The reverse() method reverses the characters in the sequence. For instance, applying reverse() on "Geeks"
will give "skeeG".

5. deleteCharAt(index):
This method removes the character at the specified index in the sequence. For example, deleting the
character at index 3 in "Geeks" will result in "Gees".

6. delete(start, end):
This method removes all characters from the specified start index to end-1. For instance, deleting characters
from index 1 to 4 in "Geeks" will result in "Gs".

7. capacity():
The capacity() method returns the current storage capacity of the sequence. It indicates how much data can
be stored before the sequence needs to resize itself.

8. replace(start, end, str):

This method replaces the characters between the specified start and end indices with a new string. For
example, replacing characters from index 1 to 4 in "GeeksForGeeks" with "Hello" will result in "GHelloGeeks".
Here is an example program to demonstrate working of the key functions:

class GfG

public static void main (String[] args) {

// StringBuilder or StringBuffer class

StringBuilder sb = new StringBuilder("dcba")

// Reversing the StringBuilder

sb.reverse();

System.out.println(sb);

// Appending to sb

sb.append("efg");

System.out.println(sb);

// Replacing the character at 1

// with h

sb.setCharAt(1, 'h');

System.out.println(sb);

// Delete the characters at 0, 1

sb.delete(0, 2);

System.out.println(sb);

// Inserts "efg" at 1

sb.insert(1, "efg");

System.out.println(sb);

Output

abcd

abcdefg

ahcdefg

cdefg

cefgdefg