Java String Class
Last modified: April 13, 2025
The java.lang.String class represents character strings in Java.
All string literals in Java programs are implemented as instances of this class.
Strings are immutable, meaning their values cannot be changed after creation.
The String class provides methods for examining individual characters, comparing strings, searching strings, extracting substrings, and creating copies with case conversion. String concatenation is implemented through the StringBuilder class for better performance.
String Class Methods
The String class provides numerous methods for string manipulation and
examination. Key methods include length, charAt,
substring, equals, compareTo, and
indexOf. These methods enable comprehensive string handling.
public final class String implements Serializable, Comparable<String>, CharSequence {
public int length() {...}
public char charAt(int index) {...}
public String substring(int beginIndex) {...}
public boolean equals(Object anObject) {...}
public int compareTo(String anotherString) {...}
public int indexOf(int ch) {...}
public String toLowerCase() {...}
public String toUpperCase() {...}
public String trim() {...}
// Many more methods...
}
The code above shows some fundamental methods provided by the String class. These methods form the core functionality for string operations in Java.
String Creation and Basic Methods
Strings can be created using literals or the new keyword. The String class
provides basic methods like length and charAt for
examining strings. String literals are stored in the string pool for efficiency.
package com.zetcode;
public class Main {
public static void main(String[] args) {
// String creation
String str1 = "Hello";
String str2 = new String("World");
String str3 = new String(new char[]{'J', 'a', 'v', 'a'});
// Basic methods
System.out.println("str1 length: " + str1.length());
System.out.println("str2 char at 2: " + str2.charAt(2));
System.out.println("str3: " + str3);
// String concatenation
String combined = str1 + " " + str2;
System.out.println("Combined: " + combined);
}
}
This example demonstrates different ways to create strings and basic string
operations. The length method returns string length, while
charAt accesses specific characters. String concatenation creates
a new string combining existing ones.
String Comparison Methods
String comparison can be done using equals for content comparison
or compareTo for lexicographical ordering. The ==
operator compares references, not content. Case-insensitive comparison is
available via equalsIgnoreCase.
package com.zetcode;
public class Main {
public static void main(String[] args) {
String s1 = "Java";
String s2 = "Java";
String s3 = new String("Java");
String s4 = "JAVA";
// Reference comparison
System.out.println("s1 == s2: " + (s1 == s2)); // true (string pool)
System.out.println("s1 == s3: " + (s1 == s3)); // false
// Content comparison
System.out.println("s1.equals(s2): " + s1.equals(s2)); // true
System.out.println("s1.equals(s3): " + s1.equals(s3)); // true
System.out.println("s1.equalsIgnoreCase(s4): " +
s1.equalsIgnoreCase(s4)); // true
// Lexicographical comparison
System.out.println("\"apple\".compareTo(\"banana\"): " +
"apple".compareTo("banana")); // negative
}
}
This example shows different string comparison techniques. The ==
operator checks reference equality, while equals checks content.
compareTo returns negative, zero, or positive for ordering.
String Searching Methods
The String class provides several methods for searching within strings,
including indexOf, lastIndexOf, contains,
and startsWith/endsWith. These methods help locate
substrings or characters within a string.
package com.zetcode;
public class Main {
public static void main(String[] args) {
String text = "The quick brown fox jumps over the lazy dog";
// Searching methods
System.out.println("Index of 'fox': " + text.indexOf("fox"));
System.out.println("Last index of 'the': " +
text.lastIndexOf("the"));
System.out.println("Contains 'brown'? " +
text.contains("brown"));
System.out.println("Starts with 'The'? " +
text.startsWith("The"));
System.out.println("Ends with 'dog'? " +
text.endsWith("dog"));
// Finding all occurrences
int index = -1;
while ((index = text.indexOf("o", index + 1)) != -1) {
System.out.println("Found 'o' at position: " + index);
}
}
}
This example demonstrates string searching methods. indexOf finds
the first occurrence, while lastIndexOf finds the last.
contains checks for substring presence. The loop shows how to find
all occurrences of a character.
String Manipulation Methods
String manipulation methods include substring, replace,
toUpperCase/toLowerCase, and trim.
These methods return new strings since strings are immutable. The original
string remains unchanged.
package com.zetcode;
public class Main {
public static void main(String[] args) {
String original = " Hello, World! ";
// Manipulation methods
String trimmed = original.trim();
String upper = original.toUpperCase();
String lower = original.toLowerCase();
String replaced = original.replace("World", "Java");
String substring = original.substring(3, 8);
System.out.println("Original: '" + original + "'");
System.out.println("Trimmed: '" + trimmed + "'");
System.out.println("Upper: '" + upper + "'");
System.out.println("Lower: '" + lower + "'");
System.out.println("Replaced: '" + replaced + "'");
System.out.println("Substring(3,8): '" + substring + "'");
// Chaining methods
String result = " Some Text "
.trim()
.toLowerCase()
.replace("some", "modified");
System.out.println("Chained result: '" + result + "'");
}
}
This example shows various string manipulation methods. Each method returns a new string without modifying the original. Method chaining demonstrates how to combine multiple operations in a single expression.
String Splitting and Joining
The split method divides a string into an array using a regular
expression delimiter. Java 8 introduced String.join for combining
strings with a delimiter. These methods are useful for processing CSV data or
building paths.
package com.zetcode;
public class Main {
public static void main(String[] args) {
String csv = "apple,orange,banana,grape";
String path = "usr/local/bin/java";
// Splitting strings
String[] fruits = csv.split(",");
String[] dirs = path.split("/");
System.out.println("Fruits:");
for (String fruit : fruits) {
System.out.println(fruit);
}
// Joining strings
String joinedPath = String.join("/", "usr", "local", "bin", "java");
String joinedWithDelimiter = String.join(" - ", fruits);
System.out.println("Joined path: " + joinedPath);
System.out.println("Joined with delimiter: " + joinedWithDelimiter);
// Complex splitting
String text = "Hello;World.Another-Example";
String[] parts = text.split("[;.-]");
System.out.println("Complex split:");
for (String part : parts) {
System.out.println(part);
}
}
}
This example demonstrates string splitting and joining. split can
use simple delimiters or regular expressions. String.join
concatenates strings with a specified delimiter between elements.
String Formatting
The format method provides C-style string formatting similar to
printf. Format specifiers like %s, %d, and %f control how values
are inserted into the string. This is useful for creating formatted output.
package com.zetcode;
public class Main {
public static void main(String[] args) {
// Basic formatting
String formatted = String.format("Hello, %s! You have %d messages.",
"Alice", 5);
System.out.println(formatted);
// Number formatting
double price = 19.99;
String priceStr = String.format("Price: $%.2f", price);
System.out.println(priceStr);
// Date formatting
String date = String.format("Today is %tB %te, %tY",
new java.util.Date(),
new java.util.Date(),
new java.util.Date());
System.out.println(date);
// Padding and alignment
String table = String.format("%-15s %5d %10.2f%n" +
"%-15s %5d %10.2f%n",
"Apples", 10, 2.99,
"Oranges", 5, 1.49);
System.out.println(table);
}
}
This example shows various string formatting techniques. The format
method supports different data types with precise control over formatting.
Alignment, padding, and number formatting are demonstrated in the table example.
String Performance Considerations
For intensive string operations, consider using StringBuilder or
StringBuffer instead of String concatenation. These classes
provide mutable sequences of characters for better performance when modifying
strings frequently.
package com.zetcode;
public class Main {
public static void main(String[] args) {
// Inefficient concatenation in loop
String result = "";
for (int i = 0; i < 10; i++) {
result += i; // Creates new String each time
}
System.out.println("Inefficient: " + result);
// Efficient using StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10; i++) {
sb.append(i);
}
System.out.println("Efficient: " + sb.toString());
// StringBuffer for thread safety
StringBuffer sbf = new StringBuffer();
sbf.append("Thread-safe");
sbf.append(" ");
sbf.append("version");
System.out.println(sbf.toString());
}
}
This example compares string concatenation approaches. The inefficient version creates many temporary String objects. StringBuilder provides better performance for mutable strings, while StringBuffer offers thread safety.
Source
Java String Class Documentation
In this article, we've covered the essential methods of the Java String class with practical examples. Understanding these methods is crucial for effective string manipulation in Java applications.
Author
List all Java tutorials.