procesamiento - stream java methods

¿Por qué este uso de Stream:: flatMap es incorrecto?

Question

Esperaba poder usar Stream :: flatMap como este

public static List<String> duplicate(String s) {
List<String> l = new ArrayList<String>();
l.add(s);
l.add(s);
return l;
}
listOfStrings.stream().flatMap(str -> duplicate(str)).collect(Collectors.toList());

Pero obtengo el siguiente error de compilación

Test.java:25: error: tipos incompatibles: no se pueden inferir tipo-variable (s) R listOfStrings.stream (). FlatMap (str -> duplicate (str)). Collect (Collectors.toList ());

(desajuste de argumento; tipo de retorno incorrecto en la expresión de lambda La lista no se puede convertir a Stream)
donde R, T son variables de tipo: R extends Objeto declarado en el método flatMap (Función>) T extends Objeto declarado en la interfaz Stream

En Scala puedo hacer lo que creo que es equivalente

scala> List(1,2,3).flatMap(duplicate(_))
res0: List[Int] = List(1, 1, 2, 2, 3, 3)

¿Por qué este no es un uso válido de flatMap en Java?

Answer 1

Si desea duplicar cada objeto en la secuencia varias veces, no necesita perder memoria en esto con ArrayList adicional. Hay varias alternativas más cortas y más rápidas.

• Genere una nueva secuencia usando Stream.generate , luego limítelo:

  listOfStrings.stream()
  .flatMap(str -> Stream.generate(() -> str).limit(2))
  .collect(Collectors.toList());

• Genere la secuencia de números a través de IntStream.range y IntStream.range a la misma cadena:

  listOfStrings.stream()
  .flatMap(str -> IntStream.range(0, 2).mapToObj(i -> str))
  .collect(Collectors.toList());

• Use buenas Collections.nCopies antiguas.nCopias:

  listOfStrings.stream()
  .flatMap(str -> Collections.nCopies(2, str).stream())
  .collect(Collectors.toList());

Si está seguro de que siempre duplicará exactamente dos veces, existe la alternativa más corta:

listOfStrings.stream()
.flatMap(str -> Stream.of(str, str))
.collect(Collectors.toList());

Answer 2

La expresión lambda en flatMap necesita devolver un Stream , como se puede ver con el argumento de flatMap que es de tipo Function<? super T, ? extends Stream<? extends R>> Function<? super T, ? extends Stream<? extends R>> Function<? super T, ? extends Stream<? extends R>> .

El siguiente código se compilará y ejecutará bien:

listOfStrings.stream()
.flatMap(str -> duplicate(str).stream()) // note the .stream() here
.collect(Collectors.toList());

porque la expresión lambda str -> duplicate(str).stream() es del tipo Function<String, Stream<String>> .