1. Overview
In this tutorial, we’ll get familiar with the ways to iterate over the string characters along with their time and space complexity.
2. Common Ways to Iterate Over a String
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.
2.1. for Loop
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)
}
2.2. toCharArray()
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);
}
2.3. Java 8 Stream
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.
2.4. CharacterIterator
We utilize the following methods of CharacterIterator methods to iterate over the String.
- current(): to get the current character
- next(): to move forward by one position
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();
}
3. Conclusion
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.
As usual, the source code of all these examples is available over on GitHub.
