Lista Java em array: converta uma lista de elementos em um array

Olá! Neste artigo, veremos como converter uma lista de elementos em um array de elementos em Java. Na verdade, não existem tantas maneiras de fazer isso e são todas simples, então o artigo não será complicado. Vamos decidir imediatamente com o que estamos trabalhando. Converteremos listas em arrays e, mais especificamente, uma lista de strings: I, love, learning, on, JavaRush será convertida em um array das mesmas strings. Mas primeiro, um pequeno bônus. Vamos falar sobre como escrever uma lista rapidamente.

Como escrever rapidamente uma lista para array

Lembre-se: existem dois cenários nesta vida. A primeira é total melancolia e tédio quando inicializamos uma nova lista:

List<String> wordsList = new ArrayList();

E então adicionamos valores a isso... Um por um...

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

Nada de bom. Esqueci por que a lista era necessária enquanto a criava! A segunda maneira é cortar todas as coisas desnecessárias e adotar... classes utilitárias. Por exemplo, a classe Arrays, que possui um método incrivelmente conveniente asList. Você pode passar para ele o que quiser para fazer uma lista, e o método fará disso uma lista. Algo assim:

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

Este método leva em si varargs- em certo sentido, um array. Peço desculpas pelo fato de que na palestra chamada lista para array eu ensinei o array a listar primeiro, mas as circunstâncias exigiram isso. Bem, agora vamos aos nossos métodos para converter listas em arrays.

Método número 1. Busto

Este método é perfeito para quem gosta de digitar código no teclado sem pensar muito. Uma espécie de meditação. Passo 1. Crie um array com o mesmo comprimento da lista:

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

Passo 2. Crie um loop com um contador para iterar por todos os elementos da lista e poder acessar as células do array por índice:

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

}

Etapa 3. Dentro do loop, atribuímos o valor de cada elemento da lista com índice i à célula do array com í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

Provavelmente a coisa mais ideal para usar. A interface Listpossui dois métodos toArrayque criam um array a partir da lista atual:

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

O primeiro método retorna um array de objetos contendo todos os elementos da lista atual (do primeiro ao ú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);
        }

    }
}

Vamos executar o método maine ver o seguinte:

I
love
learning
on
JavaRush

Porém, esse método tem uma peculiaridade: ele sempre retorna um array de objetos (Object[]). Portanto, o resultado retornado deve ser convertido no tipo de dados desejado. No exemplo acima, convertemos em um array de strings (String[]). Mas este método não aceita argumentos, o que pode ser conveniente em algumas situações. O segundo método também retorna um array contendo todos os elementos da lista atual (do primeiro ao último). No entanto, diferentemente do primeiro, o segundo método usa um array de um determinado tipo como argumento. Mas o resultado do segundo método não será um array de objetos, mas um array de um determinado tipo de dados - o mesmo que o tipo de dados no método array passado 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);
        }

    }
}

Se executarmos o método main, veremos as mesmas palavras na saída:

I
love
learning
on
JavaRush

Vamos falar um pouco sobre o array que é passado como argumento para o arquivo toArray. A lógica do método depende do comprimento do array transmitido. Existem três cenários possíveis:

1. O comprimento da matriz transmitida é menor que o comprimento da lista

Nesse caso, o método cria um novo array e coloca nele os elementos da lista. Demonstramos isso no exemplo acima.

2. O comprimento do elemento que está sendo passado é igual ao comprimento da lista

O método colocará os elementos da lista no array passado. Vamos demonstrar isso:

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

    }
}

Ao gerar, veremos todas as mesmas linhas e ficará claro que o método preencheu o array que criamos.

3. O comprimento da matriz transmitida é maior que o comprimento da lista

O método escreverá todos os elementos da lista em um array e escreverá o valor na célula próxima ao último elemento adicionado null. Vamos demonstrar isso:

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

    }
}

Após executar o método mainno console veremos o seguinte:

I
love
learning
on
JavaRush
null
6
7
8
9

Qual método dos três você deve escolher? Nas primeiras versões do Java, era ideal passar um array com comprimento igual ou maior que o comprimento da lista. No entanto, as JVMs modernas têm otimizações e, em alguns casos, fornecem desempenho mais rápido para um método que recebe uma matriz de comprimento menor que o comprimento da lista. Portanto, se você estiver executando uma versão moderna do Java, passe um array vazio para o método como fizemos no primeiro exemplo:

wordsList.toArray(new String[0]);

Método número 3. API de fluxo

Este método é adequado para aqueles que desejam não apenas converter uma lista em um array, mas também resolver alguns outros problemas ao longo do caminho. E também para pessoas familiarizadas com a API Java Stream. JavaRush tem um bom artigo sobre esse assunto . Nesta seção veremos vários exemplos usando streams. Como converter uma lista em um array usando streams:

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

         */
    }
}

Mas se você só precisa converter uma lista em um array, é melhor fazer isso usando o método toArraydescrito no Método nº 2. Mas se você deseja não apenas converter uma lista em um array, mas também realizar alguma ação em cada elemento, então este é o lugar certo para você. Vamos tentar converter a lista em um array para que no array final todas as linhas sejam escritas em maiú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

         */
    }
}

Aqui .map(str -> str.toUpperCase())definimos o que precisa ser feito com cada linha da lista. Nesse caso, decidimos converter cada string para maiúscula e depois coletá-la em um array. Usar a API Stream permite não apenas transformar cada valor, mas também filtrá-los. Suponha que queiramos coletar um array de uma lista de strings, mas de tal forma que apenas strings com mais de dois caracteres sejam incluídas no array:

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

Aqui na linha .filter(str -> str.length() > 2)criamos um chamado filtro que será aplicado a cada elemento da lista antes de entrar no array. Nesse caso, o método é chamado para cada linha length()e, se o resultado da expressão str.length() > 2for verdadeiro, tal linha terminará na seleção resultante e, finalmente, no array. Caso contrário, não acertará. Talvez valha a pena dizer aqui que o mesmo pode ser alcançado simplesmente iterando os elementos e impondo várias restrições. Você também pode fazer assim. A API Stream fornece uma abordagem mais funcional para resolver esses problemas.

Resultados

Neste artigo, vimos várias maneiras de converter listas em arrays:

• pesquisa simples;
• métodotoArray;
• API de fluxo.

A melhor opção é usar o método toArrayque está definido na interface List. Existem dois desses métodos:

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

O primeiro não aceita argumentos, mas retorna um array de objetos, e é por isso que na maioria das vezes você terá que recorrer à conversão explícita de tipos. O segundo retorna um array do tipo desejado, mas usa um array como argumento. É melhor passar um array vazio para o método e você ficará feliz. Usar a API Stream permite não apenas converter uma lista em um array, mas também realizar algumas ações ao longo do caminho, como filtrar ou converter elementos antes de adicioná-los ao array.

Trabalho de casa

Tente repetir você mesmo todos os exemplos deste artigo, mas em vez da lista original de strings, use uma lista de inteiros de 0 a 10. Naturalmente, você terá que adaptar algumas condições dos exemplos que se aplicam apenas a strings para o novo condições.