Java: convertir secuencia en matriz

En este tutorial, convertiremos un flujo de Java en una matriz de Java. Esto se puede hacer para tipos y objetos primitivos, usando el método Stream.toArray().

Introducción

En este tutorial, convertiremos un Java Stream en un Java Array para tipos primitivos, así como para objetos.

Stream.toArray()

El método toArray() es un método incorporado de la clase Stream que es realmente conveniente de usar cuando se convierte de Stream a una matriz. Funciona tanto para tipos primitivos como para objetos, aunque hay una ligera diferencia en el uso.

El método devuelve una nueva matriz, lo que significa que empaquetaremos los resultados en una nueva matriz para su almacenamiento. Para los objetos, tendremos que especificar el tipo de objeto y proporcionar un constructor de matriz de ese tipo al método también.

Tipos primitivos

Java 8 tiene flujos especiales para tipos primitivos, es decir, IntStream, LongStream y DoubleStream. Usemos un IntStream para almacenar un rango de enteros y luego convertirlo en una matriz:

1
2
3
4
5
6
IntStream stream = IntStream.range(10, 20);
int[] array = stream.toArray();
System.out.println("Printing array ...");

for (int i = 0; i < array.length; ++i)
    System.out.print(array[i] + " ");

Esto resulta en:

1
2
Printing array ...
10 11 12 13 14 15 16 17 18 19 

Los flujos son útiles para la manipulación de datos, por lo que es posible que desee realizar un preprocesamiento en un flujo, en lugar de una matriz, y convertirlo en uno al final:

1
2
3
4
5
6
IntStream stream = IntStream.range(10, 20);
// Filter out all even numbers
int[] array = stream.filter(x -> x%2 == 0).toArray();
System.out.println("\nPrinting even numbers ...");
for (int i = 0; i < array.length; ++i)
    System.out.print(array[i] + " ");

Esto resulta en:

1
2
Printing even numbers ...
10 12 14 16 18

Objetos

Para los objetos, el método toArray() toma una referencia de constructor de matriz para el objeto respectivo y devuelve una matriz de ese tipo. Hagamos un ‘Stream’ de objetos ‘String’ y convirtámoslo en una matriz:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
// Create a List of Strings
List<String> list = new ArrayList<>();
list.add("John");
list.add("Jenny");
list.add("Martha");

// Stream the List
Stream<String> stream = list.stream();

// Create an array using the toArray() method
String[] array = stream.toArray(String[]::new);
System.out.println("Printing String array ...");
for (int i = 0; i < array.length; ++i)
    System.out.println(array[i]);

Esto resulta en:

1
2
3
4
Printing String array...
John
Jenny
Martha

Nota: El método toArray() requiere que se use el constructor de matriz y hemos usado una referencia de método para especificar el tipo - String[]::new. toArray() devuelve una matriz del tipo especificado y, si no se especifica el tipo, se producirá una discrepancia:

1
String[] array = stream.toArray();

El resultado es un error del compilador:

1
error: incompatible types: Object[] cannot be converted to String[]

En lugar de las referencias de métodos abreviados, también podemos usar expresiones Lambda para lograr esto. Filtremos solo los nombres que comienzan con 'J':

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
// Create a List of Strings
List<String> list = new ArrayList<>();
list.add("John");
list.add("Jenny");
list.add("Martha");

// Stream the List
Stream<String> stream = list.stream();

// Filter the stream element and convert to array
String[] array = stream
        .filter(string -> string.startsWith("J"))
        .toArray(size -> new String[size]);
System.out.println("Printing names starting with 'J'...");
for (int i = 0; i < array.length; ++i)
    System.out.println(array[i]);

Esto produce:

1
2
3
Printing names starting with 'J'...
John
Jenny

Conclusión

En este artículo, hemos convertido un Stream en una matriz. Esto se puede hacer para matrices primitivas y de objetos a través del método Stream.toArray(), aunque con un uso ligeramente diferente.

Licensed under CC BY-NC-SA 4.0