¿Cómo convertir una secuencia de Java 8 en una matriz?

¿Cuál es la forma más fácil / corta de convertir un Java 8 Streamen una matriz?

El método más sencillo es utilizar el toArray(IntFunction<A[]> generator)método con una referencia de constructor de matriz. Esto se sugiere en la documentación de la API para el método .

String[] stringArray = stringStream.toArray(String[]::new);

Lo que hace es encontrar un método que toma un número entero (el tamaño) como argumento y devuelve un String[], que es exactamente lo que hace (una de las sobrecargas de) new String[].

También puedes escribir el tuyo propio IntFunction:

Stream<String> stringStream = ...;
String[] stringArray = stringStream.toArray(size -> new String[size]);

El propósito de IntFunction<A[]> generatores convertir un número entero, el tamaño de la matriz, en una nueva matriz.

Código de ejemplo:

Stream<String> stringStream = Stream.of("a", "b", "c");
String[] stringArray = stringStream.toArray(size -> new String[size]);
Arrays.stream(stringArray).forEach(System.out::println);

Huellas dactilares:

a
b
c

Si desea obtener una matriz de enteros, con valores de 1 a 10, de a Stream<Integer>, está IntStreama su disposición.

Aquí creamos un Streamcon un Stream.ofmétodo y convertimos Stream<Integer>a en un IntStreamusando a mapToInt. Entonces podemos llamar IntStreamal toArraymétodo de.

Stream<Integer> stream = Stream.of(1,2,3,4,5,6,7,8,9,10);
//or use this to create our stream 
//Stream<Integer> stream = IntStream.rangeClosed(1, 10).boxed();
int[] array =  stream.mapToInt(x -> x).toArray();

Aquí es lo mismo, sin el Stream<Integer>, usando solo el IntStream:

int[]array2 =  IntStream.rangeClosed(1, 10).toArray();

Puede convertir una secuencia de Java 8 en una matriz utilizando este bloque de código simple:

 String[] myNewArray3 = myNewStream.toArray(String[]::new);

Pero expliquemos las cosas más, primero, creemos una lista de cadenas llenas de tres valores:

String[] stringList = {"Bachiri","Taoufiq","Abderrahman"};

Cree una secuencia a partir de la matriz dada:

Stream<String> stringStream = Arrays.stream(stringList);

ahora podemos realizar algunas operaciones en esta secuencia Ex:

Stream<String> myNewStream = stringStream.map(s -> s.toUpperCase());

y finalmente conviértalo en una matriz java 8 usando estos métodos:

1-Método clásico (interfaz funcional)

IntFunction<String[]> intFunction = new IntFunction<String[]>() {
    @Override
    public String[] apply(int value) {
        return new String[value];
    }
};


String[] myNewArray = myNewStream.toArray(intFunction);

2 -Expresión Lambda

 String[] myNewArray2 = myNewStream.toArray(value -> new String[value]);

3- Referencia de método

String[] myNewArray3 = myNewStream.toArray(String[]::new);

Referencia del método Explicación:

Es otra forma de escribir una expresión lambda que es estrictamente equivalente a la otra.

Convierta texto en una matriz de cadenas donde separe cada valor por comas y recorte cada campo, por ejemplo:

String[] stringArray = Arrays.stream(line.split(",")).map(String::trim).toArray(String[]::new);

Puede crear un recopilador personalizado que convierta una secuencia en una matriz.

public static <T> Collector<T, ?, T[]> toArray( IntFunction<T[]> converter )
{
    return Collectors.collectingAndThen( 
                  Collectors.toList(), 
                  list ->list.toArray( converter.apply( list.size() ) ) );
}

y un uso rápido

List<String> input = Arrays.asList( ..... );

String[] result = input.stream().
         .collect( CustomCollectors.**toArray**( String[]::new ) );

El uso del toArray(IntFunction<A[]> generator)método es de hecho una forma muy elegante y segura de convertir (o más correctamente, recopilar) un Stream en una matriz del mismo tipo de Stream.

Sin embargo, si el tipo de la matriz devuelta no es importante, simplemente usar el toArray()método es más fácil y más corto. Por ejemplo:

    Stream<Object> args = Stream.of(BigDecimal.ONE, "Two", 3);
    System.out.printf("%s, %s, %s!", args.toArray());

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

int[] arr=   stream.mapToInt(x->x.intValue()).toArray();

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

class Main {

    public static void main(String[] args) {
        // Create a stream of strings from list of strings
        Stream<String> myStreamOfStrings = List.of("lala", "foo", "bar").stream();

        // Convert stream to array by using toArray method
        String[] myArrayOfStrings = myStreamOfStrings.toArray(String[]::new);

        // Print results
        for (String string : myArrayOfStrings) {
            System.out.println(string);
        }
    }
}

Pruébelo en línea: https://repl.it/@SmaMa/Stream-to-array