Why doesn't the String class in Java implement Iterable?

Question

Many Java framework classes implement Iterable, however String does not. It makes sense to iterate over characters in a String, just as one can iterate over items in a regular array.

Is there a reason why String does not implement Iterable?

Answer 1

An iterator in Java specifically applies to a collection of discrete items (objects). A String is not really a "collection" of discrete characters. It is a single entity that happens to consist of characters. Therefore, it does not make sense (in some cases, or most) in the context of Collections (which is what iterators are for) to treat each individual character as a discrete entity. It makes sense (in some cases or most) to treat the String as a whole. That being said, you can treat a String as a collection or characters and access each character like this:

for (int i = 0; i < str.length(); i++) {
  System.out.println(str.charAt(i));
}

Or as others have said:

for(char c : str.toCharArray()) {
  System.out.println(c);
}

Also note that you cannot modify a character of a String in place because Strings are immutable. The mutable companion to a String is StringBuilder (or the older StringBuffer).

EDIT

To clarify based on the comments on this answer. I'm trying to explain why there is no Iterator on a String. I'm not trying to say that it's not possible. The question is if it makes sense to have an iterator on just a String. String provides CharSequence, which, if conceptually, is different from a String. A String is usually thought of as a single entity, whereas CharSequence is exactly that: a sequence of characters. It would make sense to have an iterator on a sequence of characters (i.e., on CharSequence), but not simply on a String itself.

As Foxfire has rightly pointed out in the comments, String implements the CharSequence interface, so type-wise, a String is a CharSequence. Semantically, it seems to me that they are two separate things - I'm probably being pedantic here, but when I think of a String I usually think of it as a single entity that happens to consist of characters. Consider the difference between the sequence of digits 1, 2, 3, 4 and the number 1234. Now consider the difference between the string abcd and the sequence of characters a, b, c, d. I'm trying to point out this difference.

In my opinion, asking why String doesn't have an iterator is like asking why Integer doesn't have an iterator so that you can iterate over the individual digits.

I might be splitting hairs, but I was only trying to help ;).

Answer 2

If you are really instrested in iterating here:

String str = "StackOverflow";

for (char c: str.toCharArray()){
     //here you go
}

Answer 3

The reason is simple: The string class is much older than Iterable.

And obviously nobody ever wanted to add the interface to String (which is somewhat strange because it does implement CharSequence which is based on exactly the same idea).

However it would be somewhat imperformant because Iterable returns an object. So it would have to Wrap every Char returned.

Edit: Just as comparison: .Net does support enumerating on String, however in .Net Iterable also works on native types so there is no wrapping required as it would be required in Java.

Answer 4

Iterable of what? Iterable<Integer> would make most sense, where each element represents a Unicode codepoint. Even Iterable<Character> would be slow and pointless when we have toCharArray.

Answer 5

For what it's worth, my coworker Josh Bloch strongly wishes to add this feature to Java 7:

for (char c : aString) { ... }

and

for (int codePoint : aString) { ... }

This would be the easiest way to loop over chars and over logical characters (code points) ever. It wouldn't require making String implement Iterable, which would force boxing to happen.

Without that language feature, there's not going to be a really good answer to this problem. And he seems very optimistic that he can get this to happen, but I'm not sure.

Answer 6

They simply forgot to do so.

Answer 7

One of the main reasons for making String implement Iterable is to enable the simple for(each) loop, as mentioned above. So, a reason for not making String implement Iterable could be the inherent inefficiency of a naïve implementation, since it requires boxing the result. However, if the implementation of the resulting Iterator (as returned by String.iterator()) is final, the compiler could special-case it and generate byte-code free from boxing/unboxing.