Liste Java en tableau : convertir une liste d'éléments en tableau

Bonjour! Dans cet article, nous verrons comment convertir une liste d'éléments en un tableau d'éléments en Java. En fait, il n'y a pas tellement de façons de procéder, et elles sont toutes simples, donc l'article ne sera pas compliqué. Décidons immédiatement avec quoi nous travaillons. Nous allons convertir des listes en tableaux, et plus précisément, une liste de chaînes : I, love, learning, on, JavaRush sera converti en un tableau des mêmes chaînes. Mais d’abord, un petit bonus. Parlons de la façon de rédiger rapidement une liste.

Comment écrire rapidement une liste dans un tableau

N'oubliez pas : il y a deux scénarios dans cette vie. Le premier est la mélancolie et l’ennui total lorsque nous initialisons une nouvelle liste :

List<String> wordsList = new ArrayList();

Et puis on y ajoute des valeurs... Une à une...

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

Pas bien. J'ai oublié pourquoi la liste était nécessaire pendant que je la créais ! La deuxième façon est de supprimer toutes les choses inutiles et d'adopter... des classes utilitaires. Par exemple, la classe Arrays, qui a une méthode incroyablement pratique asList. Vous pouvez y transmettre ce que vous voulez pour en faire une liste, et la méthode en fera une liste. Quelque chose comme ça:

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

Cette méthode prend en elle varargs- en un sens, un tableau. Je m'excuse pour le fait que dans la conférence intitulée list to array, je vous ai d'abord appris à array to list, mais les circonstances l'ont exigé. Eh bien, passons maintenant à nos méthodes de conversion de listes en tableaux.

Méthode n°1. Bousiller

Cette méthode est parfaite pour ceux qui aiment taper du code sur le clavier sans trop y penser. Une sorte de méditation. Étape 1. Créez un tableau de la même longueur que la liste :

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

Étape 2. Créez une boucle avec un compteur pour parcourir tous les éléments de la liste et pouvoir accéder aux cellules du tableau par index :

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

}

Étape 3. À l'intérieur de la boucle, nous attribuons la valeur de chaque élément de la liste d'index i à la cellule du tableau d'index i :

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

Résultat:

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éthode n°2. Méthode toArray

Probablement la chose la plus optimale à utiliser. L'interface Listdispose de deux méthodes toArrayqui créent un tableau à partir de la liste actuelle :

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

La première méthode renvoie un tableau d'objets contenant tous les éléments de la liste courante (du premier au dernier) :

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);
        }

    }
}

Exécutons la méthode mainet voyons ce qui suit :

I
love
learning
on
JavaRush

Cependant, cette méthode a une particularité : elle renvoie toujours un tableau d'objets (Object[]). Par conséquent, le résultat renvoyé doit être converti dans le type de données souhaité. Dans l'exemple ci-dessus, nous le convertissons en un tableau de chaînes (String[]). Mais cette méthode n’accepte pas les arguments, ce qui peut s’avérer pratique dans certaines situations. La deuxième méthode renvoie également un tableau contenant tous les éléments de la liste actuelle (du premier au dernier). Cependant, contrairement à la première, la seconde méthode prend comme argument un tableau d’un certain type. Mais le résultat de la deuxième méthode ne sera pas un tableau d'objets, mais un tableau d'un certain type de données - le même que le type de données dans la méthode tableau passé en arguments.

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 nous exécutons la méthode main, nous verrons les mêmes mots dans le résultat :

I
love
learning
on
JavaRush

Parlons un peu du tableau qui est passé en argument au toArray. La logique de la méthode dépend de la longueur du tableau transmis. Il existe trois scénarios possibles :

1. La longueur du tableau transmis est inférieure à la longueur de la liste

Dans ce cas, la méthode crée un nouveau tableau et y place les éléments de la liste. Nous l’avons démontré dans l’exemple ci-dessus.

2. La longueur de l'élément transmis est égale à la longueur de la liste

La méthode placera les éléments de la liste dans le tableau transmis. Démontrons ceci :

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);
        }

    }
}

Lors de la sortie, nous verrons toutes les mêmes lignes et il deviendra clair que la méthode a rempli le tableau que nous avons créé.

3. La longueur du tableau transmis est supérieure à la longueur de la liste

La méthode écrira tous les éléments de la liste dans un tableau et écrira la valeur dans la cellule à côté du dernier élément ajouté null. Démontrons ceci :

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);
        }

    }
}

Après avoir exécuté la méthode maindans la console, nous verrons ce qui suit :

I
love
learning
on
JavaRush
null
6
7
8
9

Quelle méthode des trois choisir ? Dans les premières versions de Java, il était optimal de transmettre un tableau d'une longueur égale ou supérieure à la longueur de la liste. Cependant, les JVM modernes ont des optimisations et, dans certains cas, elles offrent des performances plus rapides pour une méthode à laquelle est transmis un tableau d'une longueur plus courte que la longueur de la liste. Donc, si vous utilisez une version moderne de Java, transmettez un tableau vide à la méthode comme nous l'avons fait dans le premier exemple :

wordsList.toArray(new String[0]);

Méthode numéro 3. API de flux

Cette méthode convient à ceux qui souhaitent non seulement convertir une liste en tableau, mais également résoudre quelques autres problèmes en cours de route. Et aussi pour les personnes familiarisées avec l'API Java Stream. JavaRush a un bon article sur ce sujet . Dans cette section, nous examinerons plusieurs exemples utilisant des flux. Comment convertir une liste en tableau à l'aide de flux :

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

         */
    }
}

Mais si vous avez simplement besoin de convertir une liste en tableau, il est préférable de le faire en utilisant la méthode toArraydécrite dans la méthode n° 2. Mais si vous souhaitez non seulement convertir une liste en tableau, mais également effectuer une action sur chaque élément, alors c'est le bon endroit pour vous. Essayons de convertir la liste en tableau afin que dans le tableau final toutes les lignes soient écrites en majuscules :

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

         */
    }
}

Ici, .map(str -> str.toUpperCase())nous avons défini ce qui doit être fait avec chaque ligne de la liste. Dans ce cas, nous avons décidé de convertir chaque chaîne en majuscules, puis de la collecter dans un tableau. L'utilisation de l'API Stream vous permet non seulement de transformer chaque valeur, mais également de les filtrer. Supposons que nous souhaitions collecter un tableau à partir d'une liste de chaînes, mais de telle manière que seules les chaînes de plus de deux caractères soient incluses dans le tableau :

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
         */
    }
}

Ici, dans la ligne, .filter(str -> str.length() > 2)nous avons créé un soi-disant filtre qui sera appliqué à chaque élément de la liste avant qu'il n'entre dans le tableau. Dans ce cas, la méthode est appelée pour chaque ligne length(), et si le résultat de l'expression str.length() > 2est vrai, une telle ligne se retrouvera dans la sélection résultante, et finalement dans le tableau. Sinon, ça ne frappera pas. Ici, peut-être vaut-il la peine de dire que le même résultat peut être obtenu en parcourant simplement les éléments et en imposant diverses restrictions. Vous pouvez également le faire de cette façon. L'API Stream fournit une approche plus fonctionnelle pour résoudre de tels problèmes.

Résultats

Dans cet article, nous avons examiné différentes manières de convertir des listes en tableaux :

• recherche simple ;
• méthodetoArray;
• API de flux.

La meilleure option est d'utiliser la méthode toArraydéfinie dans l'interface List. Il existe deux méthodes de ce type :

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

Le premier n'accepte pas d'arguments, mais renvoie un tableau d'objets, c'est pourquoi vous devrez le plus souvent recourir à un transtypage explicite. La seconde renvoie un tableau du type souhaité, mais prend un tableau comme argument. Il est préférable de transmettre un tableau vide à la méthode et vous serez satisfait. L'utilisation de l'API Stream vous permet non seulement de convertir une liste en tableau, mais également d'effectuer certaines actions en cours de route, telles que filtrer ou convertir des éléments avant de les ajouter au tableau.

Devoirs

Essayez de répéter vous-même tous les exemples de cet article, mais au lieu de la liste de chaînes d'origine, utilisez une liste d'entiers de 0 à 10. Naturellement, vous devrez adapter certaines conditions des exemples qui s'appliquent uniquement aux chaînes au nouveau conditions.