Iterating Through Strings Effectively
Learn the optimal ways to loop through string characters, addressing string immutability and character encoding nuances.
Strings Are Just Arrays (Usually)
In technical interviews, string manipulation problems (like checking palindromes or reversing words) are incredibly common. Under the hood, a string is simply an array of characters, which means you can loop through them just like arrays.
The Basic Iteration
In most languages, you can iterate through a string using a standard for loop and an index:
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
// Process character
}
The Immutability Problem
The biggest trap beginners face is attempting to modify the string inside the loop:
// Bad Practice (Java/Python/JS)
for (int i = 0; i < str.length(); i++) {
str += "a"; // Creates a new string every iteration!
}
Strings in Java, Python, and JavaScript are immutable. They cannot be changed. When you concatenate a string in a loop, the computer destroys the old string and creates a brand new one in memory. Doing this inside a loop changes an O(N) operation into a disastrous O(N^2) memory leak.
The Fix: Use a StringBuilder (Java), join an array of characters (Python/JS), or convert the string to a character array before looping.
For-Each Loops
If you don't need the index and just want to look at the characters, modern languages offer enhanced for-loops:
// Python
for char in my_string:
print(char)
This is highly readable and less prone to off-by-one errors.
The Takeaway
Looping through strings is identical to arrays, but modifying them is not. Always be hyper-aware of string immutability. If an algorithmic problem requires heavy string modification, convert the string to a mutable data structure before iterating.
Structurally it is the same. The main difference is that strings are often immutable, meaning you cannot change individual characters in-place during the loop.
Immutability means that once a string is created in memory, its contents cannot be altered. Any modification results in the creation of a brand new string.
Because strings are immutable, adding to a string inside a loop forces the computer to reallocate memory and copy the data repeatedly, resulting in O(N^2) time complexity.
Use a mutable data structure like a StringBuilder in Java, or push characters to an array in JS/Python and join them at the end.
Yes, most modern languages allow you to iterate directly over the characters of a string using a for-each construct, which is safer and cleaner than index tracking.