¿Diferencias de Stream.toList() y Stream.collect(Collectors.toList()) de Java 16?

JDK 16 ahora incluye un toList() método directamente en Stream instancias. En versiones anteriores de Java, siempre tenía que usar el collect método y proporcionar un Collector instancia.

El nuevo método obviamente tiene menos caracteres para escribir. ¿Ambos métodos son intercambiables o hay diferencias sutiles que uno debe tener en cuenta?

var newList = someCollection.stream()
    .map(x -> mapX(x))
    .filter(x -> filterX(x))
    .toList();

// vs.

var oldList = someCollection.stream()
    .map(x -> mapX(x))
    .filter(x -> filterX(x))
    .collect(Collectors.toList());

(Esta pregunta es similar a ¿Funcionaría mejor Stream.toList() que Collectors.toList(), pero se centra en el comportamiento y no (solo) en el rendimiento).

Una diferencia es que Stream.toList() provee un List implementación que es inmutable (tipo ImmutableCollections.ListN que no se pueden agregar o clasificar) similar a la proporcionada por List.of() y en contraste con el mutable (se puede cambiar y ordenar) ArrayList proporcionado por Stream.collect(Collectors.toList()).

Manifestación:

import java.util.stream.Stream;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> list = Stream.of("Hello").toList();
        System.out.println(list);
        list.add("Hi");
    }
}

Producción:

[Hello]
Exception in thread "main" java.lang.UnsupportedOperationException
    at java.base/java.util.ImmutableCollections.uoe(ImmutableCollections.java:142)
    at java.base/java.util.ImmutableCollections$AbstractImmutableCollection.add(ImmutableCollections.java:147)
    at Main.main(Main.java:8)

por favor, compruebe Este artículo para más detalles.

Actualizar:

Curiosamente, Stream.toList() devuelve un nulllista que contiene s con éxito.

import java.util.stream.Stream;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Object> list = Stream.of(null, null).toList();
        System.out.println(list);
    }
}

Producción:

[null, null]

Por otro lado, List.of(null, null) lanza NullPointerException.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Object> list = List.of(null, null);
    }
}

Producción:

Exception in thread "main" java.lang.NullPointerException
    at java.base/java.util.Objects.requireNonNull(Objects.java:208)
    at java.base/java.util.ImmutableCollections$List12.<init>(ImmutableCollections.java:453)
    at java.base/java.util.List.of(List.java:827)
    at Main.main(Main.java:5)

Nota: he usado openjdk-16-ea+34_osx-x64 para compilar y ejecutar el código Java SE 16.

Recursos útiles:

1. Error de JDK #JDK-8180352
2. ¿Llamar al método varargs de Java con un solo argumento nulo?

Aquí hay una pequeña tabla que resume las diferencias entre Stream.collect(Collectors.toList()), Stream.collect(Collectors.toUnmodifiableList()) y Stream.toList():

Otra pequeña diferencia:

// Compiles
List<CharSequence> list = Stream.of("hello", "world").collect(toList());

// Error
List<CharSequence> list = Stream.of("hello", "world").toList();

.collect(toList()) y toList() comportarse diferente con respecto a la compatibilidad de subtipo de los elementos en las listas creadas.

Echa un vistazo a las siguientes alternativas:

• List<Number> old = Stream.of(0).collect(Collectors.toList()); funciona bien, aunque recopilamos un flujo de Entero en una lista de Número.
• List<Number> new = Stream.of(0).toList(); es la versión equivalente de Java 16+, pero no compila (cannot convert from List<Integer> to List<Number>; al menos en ecj, el compilador Java de Eclipse).

Hay al menos 2 soluciones para corregir el error de compilación:

• Emitir explícitamente al tipo buscado
  List<Number> fix1 = Stream.of(0).map(Number.class::cast).toList();
• permitir subtipos en la colección de resultados:
  List<? extends Number> fix2 = Stream.of(0).toList();

Según tengo entendido, la causa raíz es la siguiente: el tipo genérico T de Java 16 toList() es el mismo que el tipo genérico T del propio Stream. Sin embargo, el tipo genérico T de Collectors.toList() se propaga desde el lado izquierdo de la asignación. Si esos 2 tipos son diferentes, es posible que vea errores al reemplazar todas las llamadas anteriores.