
Baeldung Pro comes with both absolutely No-Ads as well as finally with Dark Mode, for a clean learning experience:
Once the early-adopter seats are all used, the price will go up and stay at $33/year.
Last updated: May 11, 2024
In this tutorial, we’ll get familiar with the ways to iterate over the string characters along with their time and space complexity.
In Java, there are several ways to iterate over the characters of a string, each with its own time and space complexity. The best method to use depends on the specific requirements of your program.
We can use a simple for loop to iterate over the characters of a string. This method has a time complexity of O(n), where n is the length of the string str, and a space complexity of O(1) because it only requires a single loop variable:
String str = "Hello, Baeldung!";
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
System.out.print(c)
}
The toCharArray() method first converts the string into a character array, which we can use to perform the iteration. This method has a time complexity of O(n), where n is the length of the string str, and a space complexity of O(n) because it creates a new char array:
String str = "Hello, Baeldung!";
for (char c : str.toCharArray()) {
System.out.print(c);
}
We can use Java 8 Streams to process each character in the string. This approach has a time complexity of O(n) and a space complexity that depends on the intermediate operations you perform on the stream:
String str = "Hello, Baeldung!";
str.chars().forEach(c -> {
System.out.print((char) c);
});
Note that in the above code, we need to typecast the variable c to char because chars() returns an IntStream.
We utilize the following methods of CharacterIterator methods to iterate over the String.
StringCharacterIterator provides the implementation of CharacterIterator. This interface allows to have bidirectional iteration over the string. The iterator iterates over a bounded sequence of characters. Iterators maintain a current character index whose valid range is from getBeginIndex() to getEndIndex().
Here, the time complexity is O(n), where n is the length of the string str, and a space complexity of O(1) because it only requires a single while loop iterator:
String str = "Hello, Baeldung!";
CharacterIterator it = new StringCharacterIterator(str);
while (it.current() != CharacterIterator.DONE) {
System.out.print(it.current());
it.next();
}
The best method to use depends on our specific use case. For most cases, the simple for loop or the enhanced for loop is the most straightforward and efficient way to iterate over characters in a string. They have a low space complexity and a time complexity of O(n), which is the best we can achieve for this task.
We can use Java 8 Streams when we need to perform complex operations on the characters or if we want to take advantage of the functional programming capabilities it provides.