Lista de Java a matriz: convierte una lista de elementos en una matriz

¡Hola! En este artículo, veremos cómo convertir una lista de elementos en una matriz de elementos en Java. En realidad, no hay tantas formas de hacer esto y todas son sencillas, por lo que el artículo no será complicado. Decidamos inmediatamente con qué estamos trabajando. Convertiremos listas en matrices y, más específicamente, una lista de cadenas: Me encanta, estoy aprendiendo, JavaRush se convertirá en una matriz de las mismas cadenas. Pero primero, una pequeña ventaja. Hablemos de cómo escribir rápidamente una lista.

Cómo escribir rápidamente una lista en una matriz

Recuerda: hay dos escenarios en esta vida. El primero es absoluta melancolía y aburrimiento cuando inicializamos una nueva lista:

List<String> wordsList = new ArrayList();

Y luego le agregamos valores... Uno por uno...

wordsList.add("I");
wordsList.add("love");
wordsList.add("learning");
wordsList.add("on");
wordsList.add("JavaRush");

No es bueno. ¡Olvidé por qué era necesaria la lista mientras la creaba! La segunda forma es eliminar todo lo innecesario y adoptar... clases de utilidad. Por ejemplo, la clase Arrays, que tiene un método increíblemente conveniente asList. Puede pasarle lo que quiera para hacer una lista, y el método la convertirá en una lista. Algo como esto:

List<String> wordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush");

Este método toma en sí mismo varargs, en cierto sentido, una matriz. Pido disculpas por el hecho de que en la conferencia llamada lista a matriz les enseñé primero la lista a matriz, pero las circunstancias así lo requirieron. Bueno, ahora veamos nuestros métodos para convertir listas en matrices.

Método número 1. Busto

Este método es perfecto para quienes les gusta escribir código en el teclado sin pensarlo mucho. Una especie de meditación. Paso 1. Crea una matriz de la misma longitud que la lista:

List<String> wordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush");
String[] wordsArray = new String[wordsList.size()];

Paso 2. Crea un bucle con un contador para recorrer todos los elementos de la lista y poder acceder a las celdas del array por índice:

for (int i = 0; i < wordsList.size(); i++) {

}

Paso 3. Dentro del bucle, asignamos el valor de cada elemento de la lista con índice i a la celda del array con índice i:

for (int i = 0; i < wordsList.size(); i++) {
    wordsArray[i] = wordsList.get(i);
}

Resultado:

public static void main(String[] args) {

        List<String> wordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush");
        String[] wordsArray = new String[wordsList.size()];

        for (int i = 0; i < wordsList.size(); i++) {
            wordsArray[i] = wordsList.get(i);
        }
    }

Método número 2. Método toArray

Probablemente lo más óptimo para usar. La interfaz Listtiene dos métodos toArrayque crean una matriz a partir de la lista actual:

Object[] toArray();
 T[] toArray(T[] a);

El primer método devuelve una matriz de objetos que contiene todos los elementos de la lista actual (del primero al último):

public class Main {
    public static void main(String[] args) {
        List<String> wordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush");
        String[] wordsArray = (String[]) wordsList.toArray();

        for (String word : wordsArray) {
            System.out.println(word);
        }

    }
}

Ejecutemos el método mainy veamos lo siguiente:

I
love
learning
on
JavaRush

Sin embargo, este método tiene una peculiaridad: siempre devuelve una matriz de objetos (Object[]). Por lo tanto, el resultado devuelto debe convertirse al tipo de datos deseado. En el ejemplo anterior lo convertimos en una matriz de cadenas (String[]). Pero este método no acepta argumentos, lo que puede resultar conveniente en algunas situaciones. El segundo método también devuelve una matriz que contiene todos los elementos de la lista actual (del primero al último). Sin embargo, a diferencia del primero, el segundo método toma como argumento una matriz de cierto tipo. Pero el resultado del segundo método no será una matriz de objetos, sino una matriz de un determinado tipo de datos, el mismo tipo de datos en el método de matriz pasado como argumentos.

public class Main {
    public static void main(String[] args) {
        List<String> wordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush");
        String[] wordsArray = wordsList.toArray(new String[0]);

        for (String word : wordsArray) {
            System.out.println(word);
        }

    }
}

Si ejecutamos el método main, veremos las mismas palabras en el resultado:

I
love
learning
on
JavaRush

Hablemos un poco sobre la matriz que se pasa como argumento al archivo toArray. La lógica del método depende de la longitud de la matriz transmitida. Hay tres escenarios posibles:

1. La longitud de la matriz transmitida es menor que la longitud de la lista.

En este caso, el método crea una nueva matriz y coloca en ella los elementos de la lista. Demostramos esto en el ejemplo anterior.

2. La longitud del elemento que se pasa es igual a la longitud de la lista.

El método colocará los elementos de la lista en la matriz pasada. Demostremos esto:

public class Main {
    public static void main(String[] args) {
        List<String> wordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush");

        // Создаем пустой массив нужной длины
        String[] array = new String[wordsList.size()];

        // Отправляем пустой массив в метод toArray
        wordsList.toArray(array);

        // Проверяем, заполнился ли наш массив. Спойлер: да
        for (String word : array) {
            System.out.println(word);
        }

    }
}

Al generar, veremos todas las mismas líneas y quedará claro que el método ha llenado la matriz que creamos.

3. La longitud de la matriz transmitida es mayor que la longitud de la lista.

El método escribirá todos los elementos de la lista en una matriz y escribirá el valor en la celda al lado del último elemento agregado null. Demostremos esto:

public class Main {
    public static void main(String[] args) {
        List<String> wordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush");

        // Создаем пустой массив, длина которого в 2 раза больше длины списка
        String[] array = new String[wordsList.size() * 2];

        for (int i = 0; i < array.length; i++) {
            // В каждую ячейку запишем строковое представление текущего индекса
            array[i] = String.valueOf(i);
        }

        // Отправляем массив в метод toArray
        wordsList.toArray(array);

        // Проверяем, что лежит в нашем массиве
        for (String word : array) {
            System.out.println(word);
        }

    }
}

Luego de ejecutar el método mainen la consola veremos lo siguiente:

I
love
learning
on
JavaRush
null
6
7
8
9

¿Qué método de los tres deberías elegir? En las primeras versiones de Java, lo óptimo era pasar una matriz con una longitud igual o mayor que la longitud de la lista. Sin embargo, las JVM modernas tienen optimizaciones y, en algunos casos, proporcionan un rendimiento más rápido para un método al que se le pasa una matriz de longitud más corta que la longitud de la lista. Entonces, si estás ejecutando una versión moderna de Java, pasa una matriz vacía al método como hicimos en el primer ejemplo:

wordsList.toArray(new String[0]);

Método número 3. API de transmisión

Este método es adecuado para aquellos que no sólo quieren convertir una lista en una matriz, sino también resolver un par de problemas más en el camino. Y también para personas familiarizadas con la API Java Stream. JavaRush tiene un buen artículo sobre este tema . En esta sección veremos varios ejemplos que utilizan transmisiones. Cómo convertir una lista en una matriz usando transmisiones:

public class Main {
    public static void main(String[] args) {
        List<String> wordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush");

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

        for (String s : strings) {
            System.out.println(s);
        }

        /*
        Output:
        I
        love
        learning
        on
        JavaRush

         */
    }
}

Pero si solo necesita convertir una lista en una matriz, entonces es mejor hacerlo usando el método toArraydescrito en el Método No. 2. Pero si no sólo desea convertir una lista en una matriz, sino también realizar alguna acción en cada elemento, entonces este es el lugar adecuado para usted. Intentemos convertir la lista en una matriz para que en la matriz final todas las líneas estén escritas en mayúsculas:

public class Main {
    public static void main(String[] args) {
        List<String> wordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush");

        String[] strings = wordsList.stream()
                .map(str -> str.toUpperCase())
                .toArray(String[]::new);

        for (String s : strings) {
            System.out.println(s);
        }

        /*
            Output:
            I
            LOVE
            LEARNING
            ON
            JAVARUSH

         */
    }
}

Aquí .map(str -> str.toUpperCase())hemos definido lo que se debe hacer con cada línea de la lista. En este caso, decidimos convertir cada cadena a mayúsculas y luego recopilarla en una matriz. El uso de Stream API le permite no solo transformar cada valor, sino también filtrarlos. Supongamos que queremos recopilar una matriz de una lista de cadenas, pero de tal manera que solo se incluyan en la matriz cadenas de más de dos caracteres:

public class Main {
    public static void main(String[] args) {
        List<String> wordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush");

        String[] strings = wordsList.stream()
                .filter(str -> str.length() > 2)
                .map(str -> str.toUpperCase())
                .toArray(String[]::new);

        for (String s : strings) {
            System.out.println(s);
        }

        /*
            Output:
            LOVE
            LEARNING
            JAVARUSH
         */
    }
}

Aquí en la línea .filter(str -> str.length() > 2)hemos creado un llamado filtro que se aplicará a cada elemento de la lista antes de ingresar a la matriz. En este caso, el método se llama para cada fila length()y, si el resultado de la expresión str.length() > 2es verdadero, dicha fila terminará en la selección resultante y, finalmente, en la matriz. De lo contrario, no impactará. Aquí, tal vez, valga la pena decir que se puede lograr lo mismo simplemente iterando sobre los elementos e imponiendo varias restricciones. Puedes hacerlo de esta manera también. Stream API proporciona un enfoque más funcional para resolver estos problemas.

Resultados

En este artículo, analizamos varias formas de convertir listas en matrices:

• búsqueda sencilla;
• métodotoArray;
• API de transmisión.

La mejor opción es utilizar el método toArrayque está definido en la interfaz List. Hay dos métodos de este tipo:

• Object[] toArray();
• T[] toArray(T[] a);

El primero no acepta argumentos, pero devuelve una matriz de objetos, por lo que la mayoría de las veces tendrás que recurrir a la conversión de tipos explícita. El segundo devuelve una matriz del tipo deseado, pero toma una matriz como argumento. Es mejor pasar una matriz vacía al método y quedará satisfecho. El uso de Stream API le permite no solo convertir una lista en una matriz, sino también realizar algunas acciones en el camino, como filtrar o convertir elementos antes de agregarlos a la matriz.

Tarea

Intente repetir todos los ejemplos de este artículo usted mismo, pero en lugar de la lista original de cadenas, use una lista de números enteros del 0 al 10. Naturalmente, tendrá que adaptar algunas condiciones de los ejemplos que se aplican solo a las cadenas al nuevo condiciones.