Pregunta de estilo para variar de las peticiones de ayuda: los Streams de Java (desde Java 8) ¿os parecen que hacen el código más claro, o a veces complican algo que un bucle normal resolvería igual de bien?

Ejemplo donde para mí sí ganan claramente, filtrar y transformar una lista:

List<String> nombresLargos = personas.stream()
    .filter(p -> p.getEdad() >= 18)
    .map(Persona::getNombre)
    .sorted()
    .collect(Collectors.toList());

Frente al equivalente con bucle:

List<String> nombresLargos = new ArrayList<>();
for (Persona p : personas) {
    if (p.getEdad() >= 18) {
        nombresLargos.add(p.getNombre());
    }
}
Collections.sort(nombresLargos);

El stream deja clarísimo «qué» se hace (filtrar, transformar, ordenar, recolectar) sin que tengas que leer todo el bucle para deducirlo.

Donde para mí empiezan a complicar en vez de ayudar: cuando encadenas muchas operaciones con lógica condicional compleja dentro de cada lambda, o cuando necesitas depurar paso a paso y el stream no te deja poner un breakpoint intermedio cómodamente (aunque .peek() ayuda algo para depurar). Ahí un bucle normal, aunque sea más largo, a veces se entiende y se depura más rápido.

¿Dónde ponéis vosotros el límite entre «esto queda mejor como stream» y «esto ya es más lío que un bucle»?

Ruben

A mí me aclaran el código cuando la cadena de operaciones es lineal y se lee de arriba abajo como una frase: filtrar, transformar, recoger resultado. Algo como:

List<String> nombres = personas.stream()
  .filter(p -> p.getEdad() >= 18)
  .map(Persona::getNombre)
  .sorted()
  .collect(Collectors.toList());

ahí el stream gana claramente al bucle equivalente en legibilidad, se entiende de un vistazo qué hace sin tener que seguir el estado de una variable acumuladora paso a paso.

Donde empiezan a complicarse, para mí, es en dos casos concretos: cuando necesitas mantener varios estados/índices a la vez dentro del propio stream (ahí acabas con trucos raros tipo AtomicInteger capturado en el lambda solo para llevar la cuenta, que es peor que un simple for con su índice), y cuando hay que depurar algo que falla a mitad de la cadena. Poner un breakpoint dentro de un lambda en medio de una cadena de streams es bastante más incómodo que en un bucle normal, donde puedes ir viendo el estado de las variables línea a línea sin complicaciones.

Mi regla personal: si la operación se puede describir en una frase corta ("filtra esto, transforma esto, junta esto"), stream. Si tengo que explicar el algoritmo con "primero hago esto, y mientras tanto voy guardando aquello", bucle de toda la vida.

Sara