As others have already mentioned, the design decision behind this was to prevent the explosion of methods and classes.
Still, personally I think this was a very bad decision, and there should, given they do not want to make CharStream
, which is reasonable, different methods instead of chars()
, I would think of:
Stream<Character> chars()
, that gives a stream of boxes characters, which will have some light performance penalty.IntStream unboxedChars()
, which would to be used for performance code.
However, instead of focusing on why it is done this way currently, I think this answer should focus on showing a way to do it with the API that we have gotten with Java 8.
In Java 7 I would have done it like this:
for (int i = 0; i < hello.length(); i++) {
System.out.println(hello.charAt(i));
}
And I think a reasonable method to do it in Java 8 is the following:
hello.chars()
.mapToObj(i -> (char)i)
.forEach(System.out::println);
Here I obtain an IntStream
and map it to an object via the lambda i -> (char)i
, this will automatically box it into a Stream<Character>
, and then we can do what we want, and still use method references as a plus.
Be aware though that you must do mapToObj
, if you forget and use map
, then nothing will complain, but you will still end up with an IntStream
, and you might be left off wondering why it prints the integer values instead of the strings representing the characters.
Other ugly alternatives for Java 8:
By remaining in an IntStream
and wanting to print them ultimately, you cannot use method references anymore for printing:
hello.chars()
.forEach(i -> System.out.println((char)i));
Moreover, using method references to your own method do not work anymore! Consider the following:
private void print(char c) {
System.out.println(c);
}
and then
hello.chars()
.forEach(this::print);
This will give a compile error, as there possibly is a lossy conversion.
Conclusion:
The API was designed this way because of not wanting to add CharStream
, I personally think that the method should return a Stream<Character>
, and the workaround currently is to use mapToObj(i -> (char)i)
on an IntStream
to be able to work properly with them.