Elenco Java in array: converte un elenco di elementi in un array

Ciao! In questo articolo vedremo come convertire un elenco di elementi in un array di elementi in Java. In realtà, non ci sono molti modi per farlo e sono tutti semplici, quindi l'articolo non sarà complicato. Decidiamo immediatamente con cosa stiamo lavorando. Convertiremo gli elenchi in array e, più specificamente, un elenco di stringhe: I, love, learning, on, JavaRush verrà convertito in un array delle stesse stringhe. Ma prima, un piccolo bonus. Parliamo di come scrivere rapidamente un elenco.

Come scrivere rapidamente un elenco nell'array

Ricorda: ci sono due scenari in questa vita. Il primo è la totale malinconia e noia quando inizializziamo una nuova lista:

List<String> wordsList = new ArrayList();

E poi gli aggiungiamo valori... Uno per uno...

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

Non buono. Ho dimenticato il motivo per cui l'elenco era necessario mentre lo stavo creando! Il secondo modo è eliminare tutte le cose non necessarie e adottare... classi di utilità. Ad esempio, la classe Arrays, che ha un metodo incredibilmente conveniente asList. Puoi passarci tutto ciò che vuoi per creare un elenco e il metodo lo renderà un elenco. Qualcosa come questo:

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

Questo metodo contiene in sé varargs, in un certo senso, un array. Mi scuso per il fatto che nella lezione intitolata list to array ti ho insegnato prima array to list, ma le circostanze lo richiedevano. Bene, passiamo ora ai nostri metodi per convertire le liste in array.

Metodo n. 1. Torace

Questo metodo è perfetto per coloro a cui piace digitare il codice sulla tastiera senza pensarci troppo. Una sorta di meditazione. Passaggio 1. Crea un array della stessa lunghezza dell'elenco:

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

Passaggio 2. Crea un ciclo con un contatore per scorrere tutti gli elementi dell'elenco ed essere in grado di accedere alle celle dell'array in base all'indice:

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

}

Passaggio 3. All'interno del ciclo, assegniamo il valore di ciascun elemento della lista con indice i alla cella dell'array con indice i:

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

Risultato:

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

Metodo n. 2. metodo toArray

Probabilmente la cosa più ottimale da usare. L'interfaccia Listdispone di due metodi toArrayche creano un array dall'elenco corrente:

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

Il primo metodo restituisce un array di oggetti contenente tutti gli elementi della lista corrente (dal primo all'ultimo):

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

    }
}

Eseguiamo il metodo maine vediamo quanto segue:

I
love
learning
on
JavaRush

Questo metodo ha però una particolarità: restituisce sempre un array di oggetti (Object[]). Pertanto, il risultato restituito deve essere convertito nel tipo di dati desiderato. Nell'esempio sopra lo abbiamo lanciato su un array di stringhe (String[]). Ma questo metodo non accetta argomenti, il che può essere conveniente in alcune situazioni. Anche il secondo metodo restituisce un array contenente tutti gli elementi della lista corrente (dal primo all'ultimo). Tuttavia, a differenza del primo, il secondo metodo accetta come argomento un array di un certo tipo. Ma il risultato del secondo metodo non sarà un array di oggetti, ma un array di un certo tipo di dati, lo stesso del tipo di dati passato come argomento nel metodo array.

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

    }
}

Se eseguiamo il metodo main, vedremo le stesse parole nell'output:

I
love
learning
on
JavaRush

Parliamo un po' dell'array che viene passato come argomento al file toArray. La logica del metodo dipende dalla lunghezza dell'array trasmesso. Ci sono tre possibili scenari:

1. La lunghezza dell'array trasmesso è inferiore alla lunghezza dell'elenco

In questo caso, il metodo crea un nuovo array e vi inserisce gli elementi dell'elenco. Lo abbiamo dimostrato nell’esempio sopra.

2. La lunghezza dell'elemento passato è uguale alla lunghezza dell'elenco

Il metodo inserirà gli elementi dell'elenco nell'array passato. Dimostriamolo:

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

    }
}

Durante l'output, vedremo tutte le stesse righe e diventerà chiaro che il metodo ha riempito l'array che abbiamo creato.

3. La lunghezza dell'array trasmesso è maggiore della lunghezza dell'elenco

Il metodo scriverà tutti gli elementi della lista in un array e scriverà il valore nella cella accanto all'ultimo elemento aggiunto null. Dimostriamolo:

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

    }
}

Dopo aver eseguito il metodo mainnella console vedremo quanto segue:

I
love
learning
on
JavaRush
null
6
7
8
9

Quale metodo tra i tre dovresti scegliere? Nelle prime versioni di Java, era ottimale passare un array con una lunghezza uguale o maggiore della lunghezza dell'elenco. Tuttavia, le JVM moderne dispongono di ottimizzazioni e in alcuni casi forniscono prestazioni più veloci per un metodo a cui viene passato un array di lunghezza inferiore rispetto alla lunghezza dell'elenco. Quindi, se stai utilizzando una versione moderna di Java, passa un array vuoto al metodo come abbiamo fatto nel primo esempio:

wordsList.toArray(new String[0]);

Metodo numero 3. API di flusso

Questo metodo è adatto a coloro che desiderano non solo convertire un elenco in un array, ma anche risolvere un paio di altri problemi lungo il percorso. E anche per chi ha familiarità con l'API Java Stream. JavaRush ha un buon articolo su questo argomento . In questa sezione esamineremo diversi esempi di utilizzo dei flussi. Come convertire un elenco in un array utilizzando i flussi:

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

         */
    }
}

Ma se hai solo bisogno di trasmettere un elenco a un array, allora è meglio farlo utilizzando il metodo toArraydescritto nel Metodo n. 2. Ma se vuoi non solo convertire un elenco in un array, ma anche eseguire qualche azione su ciascun elemento, allora questo è il posto giusto per te. Proviamo a convertire la lista in un array in modo che nell'array finale tutte le righe siano scritte in maiuscolo:

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

         */
    }
}

Qui .map(str -> str.toUpperCase())abbiamo definito cosa è necessario fare con ciascuna riga dell'elenco. In questo caso abbiamo deciso di convertire ogni stringa in maiuscolo e poi di raccoglierla in un array. L'utilizzo dell'API Stream ti consente non solo di trasformare ciascun valore, ma anche di filtrarlo. Supponiamo di voler raccogliere un array da un elenco di stringhe, ma in modo tale che nell'array siano incluse solo le stringhe più lunghe di due caratteri:

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

Qui nella riga .filter(str -> str.length() > 2)abbiamo creato un cosiddetto filtro che verrà applicato a ciascun elemento della lista prima che entri nell'array. In questo caso, il metodo viene chiamato per ogni riga length()e, se il risultato dell'espressione str.length() > 2è vero, tale riga finirà nella selezione risultante e, infine, nell'array. Altrimenti non colpirà. Qui, forse, vale la pena dire che lo stesso può essere ottenuto semplicemente iterando sugli elementi e imponendo varie restrizioni. Puoi farlo anche in questo modo. L'API Stream fornisce un approccio più funzionale per risolvere tali problemi.

Risultati

In questo articolo, abbiamo esaminato vari modi per convertire gli elenchi in array:

• ricerca semplice;
• metodotoArray;
• API di flusso.

L'opzione migliore è utilizzare il metodo toArraydefinito nell'interfaccia List. Esistono due metodi di questo tipo:

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

Il primo non accetta argomenti, ma restituisce un array di oggetti, motivo per cui molto spesso dovrai ricorrere al cast esplicito del tipo. Il secondo restituisce un array del tipo desiderato, ma accetta un array come argomento. È meglio passare un array vuoto al metodo e sarai felice. L'utilizzo dell'API Stream consente non solo di convertire un elenco in un array, ma anche di eseguire alcune azioni lungo il percorso, come filtrare o convertire elementi prima di aggiungerli all'array.

Compiti a casa

Prova a ripetere tu stesso tutti gli esempi di questo articolo, ma invece dell'elenco originale di stringhe, utilizza un elenco di numeri interi da 0 a 10. Naturalmente dovrai adattare alcune condizioni degli esempi che si applicano solo alle stringhe al nuovo condizioni.