Stream.flatMap() from char[] to Character stream

import java.util.*; 
import java.util.stream.*; 
  
class Playground { 
  
    public static void main(String[] args) 
    { 
        // Creating a character array 
        char arr[] = { '1', '2', '3', '4', '5' }; 
  
        // --------- Using Stream.of() --------- 
        // Will work efficiently 
  
        // to convert int array into Stream 
        Stream<char[]> stream = Stream.of(arr); 
        Stream<Integer> s = stream.flatMap((item)->new String(item).chars().mapToObj(a->(char)a));
  
        // Displaying elements in Stream 
        s.forEach(str -> System.out.print(str + " ")); 
    } 
} 

I'm trying to convert a char[] into a stream of Characters with flatMap() but I got the following error

./Playground/Playground.java:14: error: incompatible types: inference variable R has incompatible bounds
        Stream<Integer> s = stream.flatMap((item)->new String(item).chars().mapToObj(a->(char)a));
                                          ^
    equality constraints: Integer
    lower bounds: U,Character
  where R,T,U are type-variables:
    R extends Object declared in method <R>flatMap(Function<? super T,? extends Stream<? extends R>>)
    T extends Object declared in interface Stream
    U extends Object declared in method <U>mapToObj(IntFunction<? extends U>)
1 error

Need help with understanding the error and how to accomplish this task. Specifically how this fix this line of code using flatMap() from char[] to Character stream.

Stream<Integer> s = stream.flatMap((item)->new String(item).chars().mapToObj(a->(char)a))

Edit: So the problems turns out not to be about Stream but lambda expression and I twitched the line and messed the typing up after fixing the lambda expression by accident. The original line was

Stream<Character> s = stream.flatMap(item->{new String(item).chars().mapToObj(a->(char)a);});

and the issue was missing return statement inside {}. Then I altered the line to

Stream<Integer> s = stream.flatMap((item)->new String(item).chars())

because I thought IntStream::mapToObj was causing troubles however I forgot the boxed() in the end and got another type error so I added back the IntStream::mapToObj and posted the question but forgot to change the Stream type back to Character. I got confused but the fog is cleared now.Thanks for the good answers.

You were almost there. Just replace Stream<Integer> to Stream<Character>, as you are casting to a char in your code.

However, the problem about your code is that you are unnecessarily flatMapping. Stream.of expects an array with a reference type as its compound type. Further, Arrays.stream does not have an overload for char[]. You end up streaming over something that is guaranteed to be a single element. That element is your char[].

You could just drop the flatMap operation, and directly convert the char array to a String.

String str = new String(arr);
Stream<Character> characterStream = str.chars().mapToObj(c -> (char) c);

It’s not clear what you are trying to achieve with this detour of unnecessary operations. When you want to stream over an array, just start with that operation, instead of creating a single element stream, to chain flatMap, to chain another map.

Your code does already contain an approach for streaming over a char[] array, in the middle of the other operations, using the String constructor.

char[] arr = { '1', '2', '3', '4', '5' };

new String(arr).chars().forEach(i -> System.out.print(i + " "));

This will print the Unicode numbers. When you want to print characters instead, just change the terminal operation:

new String(arr).chars().forEach(i -> System.out.print((char)i + " "));

or

new String(arr).chars().forEach(i -> System.out.printf("%c ", i));

You can also use

new String(arr).chars().mapToObj(i -> (char)i).forEach(i -> System.out.print(i+" "));

but this bears boxing overhead, as it creates a Stream<Character>.

Note that new String(arr) bears a copying overhead, as it creates an immutable object. You can avoid this by using

CharBuffer.wrap(arr).chars().forEach(i -> System.out.printf("%c ", i));

Of course, you can insert as many curlicues as you want, e.g.

Stream.of(arr)
    .flatMapToInt(array -> CharBuffer.wrap(array).chars())
    .mapToObj(i -> (char)i) // returns a Stream<Character> not Stream<Integer>
    .forEach(i -> System.out.printf("%c ", i));

but there is no reason to do so.

• You can use Arrays.stream() for any array except byte, char or short.
• You can use *Stream.of() for any primitive array of type * where * is Int or Double, or Long.
• You can use Stream.of() for any Object array.

All of the following work as explained above.

Integer[] IntegerArray = {1,2,3,4};
Arrays.stream(IntegerArray).forEach(System.out::println);
Stream.of(IntegerArray).forEach(System.out::println);

int[] intArray = {1,2,3,4};
Arrays.stream(intArray).forEach(System.out::println);
IntStream.of(intArray).forEach(System.out::println);

double[] doubleArray = {1.2,3.3,4.5,6.7};
Arrays.stream(doubleArray).forEach(System.out::println);
DoubleStream.of(doubleArray).forEach(System.out::println);

String[] stringArray = {"a","b","c","d"};
Stream.of(stringArray).forEach(System.out::println);

To solve your actual problem, try this.

	 // Creating a character array 
	    char arr[] = { '1', '2', '3', '4', '5' }; 

	    // --------- Using Stream.of() --------- 
	    // Will work efficiently 

	    // to convert int array into Stream 
	    Stream<char[]> stream = Stream.of(arr); 
	    

	    // Displaying elements in Stream 
  	    s.forEach(str -> System.out.print(str + " ")); 
	    Stream<Integer> s = stream.flatMapToInt((item)->(new String(item)).chars()).boxed();
        //or
	    IntStream s = stream.flatMapToInt((item)->(new String(item)).chars());

	    // Displaying elements in Stream 
	    s.forEach(str -> System.out.print((char)str + " ")); 
  
     
        

</details>



# 答案4
**得分**: 1

以下是翻译好的部分：

你使用了 `Stream&lt;Integer&gt;`，而不是 `Stream&lt;Character&gt;`。如果你想使用 `Stream&lt;Integer&gt;`，你需要使用 [IntStream::boxed][1] 或者像下面展示的那样使用 `mapToObj(a -&gt; Integer.valueOf(a))`：

```java
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        char arr[] = { '1', '2', '3', '4', '5' };

        Stream&lt;char[]&gt; stream1 = Stream.of(arr);
        Stream&lt;Character&gt; chars = stream1.flatMap(item -&gt; new String(item).chars().mapToObj(a -&gt; (char) a));
        chars.forEach(c -&gt; System.out.print(c + " "));

        System.out.println();

        Stream&lt;char[]&gt; stream2 = Stream.of(arr);
        Stream&lt;Integer&gt; ints = stream2.flatMap(item -&gt; new String(item).chars().boxed());
        ints.forEach(i -&gt; System.out.print(i + " "));

        System.out.println();

        Stream&lt;char[]&gt; stream3 = Stream.of(arr);
        Stream&lt;Integer&gt; integers = stream3.flatMap(item -&gt; new String(item).chars().mapToObj(a -&gt; Integer.valueOf(a)));
        integers.forEach(i -&gt; System.out.print(i + " "));
    }
}

输出:

1 2 3 4 5 
49 50 51 52 53 
49 50 51 52 53 

import java.util.stream.Stream;

public class Main {
	public static void main(String[] args) {
		char arr[] = { '1', '2', '3', '4', '5' };

		Stream<char[]> stream1 = Stream.of(arr);
		Stream<Character> chars = stream1.flatMap(item -> new String(item).chars().mapToObj(a -> (char) a));
		chars.forEach(c -> System.out.print(c + " "));

		System.out.println();

		Stream<char[]> stream2 = Stream.of(arr);
		Stream<Integer> ints = stream2.flatMap(item -> new String(item).chars().boxed());
		ints.forEach(i -> System.out.print(i + " "));

		System.out.println();

		Stream<char[]> stream3 = Stream.of(arr);
		Stream<Integer> integers = stream3.flatMap(item -> new String(item).chars().mapToObj(a -> Integer.valueOf(a)));
		integers.forEach(i -> System.out.print(i + " "));
	}
}

1 2 3 4 5 
49 50 51 52 53 
49 50 51 52 53