5

I tried the following code using Java 8 streams:

Arrays.asList("A", "B").stream()
            .flatMap(s -> Arrays.asList("X", "Y").stream().map(s1 -> s + s1)).collect(Collectors.toList());

What I get is a List<Object> while I would expect a List<String>. If I remove the collect and I try:

Arrays.asList("A", "B").stream().flatMap(s -> Arrays.asList("X", "Y").stream().map(s1 -> s + s1));

I correctly get a Stream<String>.

Where am I wrong? Can someone help me?

Many thanks in advance.

Edit:

The problem is due to Eclipse (now using Kepler SR2 with java 8 patch 1.0.0.v20140317-1956). The problem does non appear if compiling using javac or, as commented by Holger, using Netbeans

Stuart Marks
  • 127,867
  • 37
  • 205
  • 259
Filippo Tabusso
  • 601
  • 3
  • 10
  • 16
  • Not for me. It returns `Stream`. Which compiler are you using? – Holger Jun 06 '14 at 09:34
  • @Holger, I am compiling inside Eclipse – Filippo Tabusso Jun 06 '14 at 09:37
  • Well, the Java 8 support of Eclipse is still in development but I suggest you carefully check whether the code you have written inside Eclipse matches what you have written here, before blaming Eclipse as it doesn’t look like a tricky language construct (compiler corner case) to me. With `Kepler SR2` and `JDT Patch with Java 8 1.0.0.v20140317-1956` it works correctly. – Holger Jun 06 '14 at 09:41
  • @Holger, you were right about the stream, I have updated my question, apparently the problem is not in the Stream but in the collect which I had initally removed to (over)simplify my question – Filippo Tabusso Jun 06 '14 at 09:59
  • Ok, *now* it looks like an Eclipse problem. With `Netbeans` you can correctly collect into a `List` – Holger Jun 06 '14 at 11:34
  • @Holger, thank you, I edited the question to underline that the problem is limited to Eclipse. – Filippo Tabusso Jun 06 '14 at 12:00

1 Answers1

6

Type inference is a new feature. Until tools and IDEs are fully developed I recommend using explicitly typed lambdas. There ware cases where Eclipse even crashed if an explicit cast was missing, but that is fixed now.

Here's a workaround:

With a typed "s1":

asList.stream()
   .flatMap(s -> Arrays.asList("X", "Y").stream().map((String s1) -> s + s1))
   .collect(Collectors.toList());

Or with a genric parameter:

asList.stream()
   .flatMap(s -> Arrays.asList("X", "Y").stream().<String>map(s1 -> s + s1))
   .collect(Collectors.toList());

The same is true if you add the parameter before flatMap instead of map.

But I suggest you use s::concat:

asList.stream()
   .flatMap(s -> Arrays.asList("X", "Y").stream().map(s::concat))
   .collect(Collectors.toList());
Claude Martin
  • 745
  • 6
  • 21