En collect () el funcionamiento del terminal de corriente, lo que sucederá si el proveedor es un objeto inmutable como una cuerda?

Erick Del Rey :

collect()método de Stream es una reducción mutable. Basado en Java Documenation:

Una operación de reducción mutable acumula elementos de entrada en un recipiente resultado mutable, como una colección o StringBuilder, a medida que procesa los elementos de la corriente.

He intentado lo siguiente y compila sin ningún problema.

Stream<String> stream1 = Stream.of("w", "o", "l", "f");
String word = stream1.collect(String::new, String::concat, String::concat);
System.out.println(word);

Si el proveedor es un StringBuffer, considero que la operación de cobro revertido como elementos se añadirá a la suministrada StringBuffer.

¿Cómo funciona la reducción mutables aquí desde cuerdas es un objeto inmutable? Va a ser el mismo que reducir la operación en la que se crea un nuevo objeto cada vez que el acumulador se implementa?

Eugene:

¿Cómo funciona la reducción mutables aquí desde cuerdas es un objeto inmutable?

No lo hace. Cuando se ejecuta de que obtendrá una cadena vacía (el resultado de la Supplier only). El compilador no puede hacer cumplir comprobar si el proveedor devuelve un objeto inmutable, que es absolutamente algo que no puede hacer. Y puesto que el contenedor es inmutable, las actualizaciones a que son simplemente ignorados. Es como hacer:

String s = "abc";
s.concat("def"); // the result is ignored here

Puede ser que si se escribe como lambda que hará mucho más sentido:

Stream<String> stream1 = Stream.of("w", "o", "l", "f");
    String word = stream1.collect(
            String::new,
            (left, right) -> {
                left.concat(right); // result is ignored
            },
            String::concat);

Por otra parte, cuando se utiliza reducir, usted está obligado a devolver algo:

String word = stream1.reduce(
            "",
            (x, y) -> {
                return x.concat(y);
            },
            (x, y) -> {
                return x.concat(y);
            });

Por supuesto, todavía se podía hacer:

String word = stream1.reduce(
            "",
            (x, y) -> {
                x.concat(y);
                return x; // kind of stupid, but you could
            },
            (x, y) -> {
                return x.concat(y);
            });

Si quería romperlo; Pero ese no es el punto.