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

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

El método más fácil es usar 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 tome un número entero (el tamaño) como argumento y devuelva a String[], que es exactamente lo que hace (una de las sobrecargas de) new String[].

También puedes escribir el tuyo IntFunction:

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

El propósito de la 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 entradas, con valores del 1 al 10, de un Stream, hay IntStream a su disposición.

Aquí creamos un Stream con un método Stream.of y convertimos un Stream en un IntStream usando un mapToInt. Entonces podemos llamar al método toArray de IntStream.

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 Stream, usando solo IntStream

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

Puede convertir un flujo de Java 8 en una matriz usando este bloque de código simple:

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

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

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

Crear una secuencia de la matriz dada:

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

ahora podemos realizar algunas operaciones en esta secuencia Ej:

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

y finalmente conviértalo a java 8 Array 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 de Lambda

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

3- Referencia del 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 el texto en una matriz de cadenas donde separe cada valor por coma 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 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 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

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

     Integer[] integers = stream.toArray(it->new Integer[it]);

Puede hacerlo de varias maneras. Todas las formas son técnicamente iguales, pero el uso de Lambda simplificaría parte del código. Digamos que inicializamos una Lista primero con String, llamémosla personas.

List<String> persons = new ArrayList<String>(){{add("a"); add("b"); add("c");}};
Stream<String> stream = persons.stream();

Ahora puede usar cualquiera de las siguientes formas.

1. Usando la expresión Lambda para crear un nuevo StringArray con un tamaño definido.

   String [] stringArray = stream.toArray (size-> new String [size]);

2. Usando el método de referencia directamente.

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