Convertendo array para lista em Java

1028

Como faço para converter uma matriz em uma lista em Java?

Eu usei o Arrays.asList()mas o comportamento (e assinatura) mudou de alguma forma do Java SE 1.4.2 (documentos agora em archive) para 8 e a maioria dos trechos que encontrei na Web usam o comportamento 1.4.2.

Por exemplo:

int[] spam = new int[] { 1, 2, 3 };
Arrays.asList(spam)
  • no 1.4.2 retorna uma lista contendo os elementos 1, 2, 3
  • em 1.5.0+ retorna uma lista contendo o spam da matriz

Em muitos casos, deve ser fácil detectar, mas às vezes pode passar despercebido:

Assert.assertTrue(Arrays.asList(spam).indexOf(4) == -1);
Alexandru
fonte
20
Eu acho que seu exemplo está quebrado Arrays.asList(new int[] { 1, 2, 3 }):; definitivamente não compilou no Java 1.4.2, porque um nãoint[] é um . Object[]
Joachim Sauer
1
Oh, você pode estar certo. Eu não tinha o compilador Java 1.4.2 por perto para testar meu exemplo antes de postar. Agora, depois do seu comentário e da resposta de Joe, tudo faz muito mais sentido.
Alexandru
1
Eu pensei que o Autoboxing teria coberto a conversão da classe Integer primitiva para wrapper. Você pode fazer o elenco primeiro e depois o código acima Arrays.asListdeve funcionar.
Horse Voice
2
O Stream.boxed () do Java 8 cuida da caixa automática e pode ser usado para isso. Veja minha resposta abaixo .
Ibrahim Arief
Solução Java 8: stackoverflow.com/questions/2607289/…
akhil_mittal

Respostas:

1431

No seu exemplo, é porque você não pode ter uma lista de um tipo primitivo. Em outras palavras, List<int>não é possível.

No entanto, você pode List<Integer>usar a Integerclasse que agrupa o intprimitivo. Converta sua matriz em um Listcom o Arrays.asListmétodo utilitário

Integer[] spam = new Integer[] { 1, 2, 3 };
List<Integer> list = Arrays.asList(spam);

Veja este código executado ao vivo em IdeOne.com .

Joe Daley
fonte
112
Ou ainda mais simples: Arrays.asList (1, 2, 3);
24513 Kong
45
Como ele sabe não criar um List<Integer[]>?
Thomas Ahle
25
Falha no Java 5+.
djechlin
6
@ThomasAhle Ele não cria uma Lista <Inteiro []> e cria um objeto List <Integer>. E se você quiser digitar com segurança, escreva: Arrays. <Integer> asList (spam);
User1712376
6
@ThomasAhle Essa é uma boa pergunta. Um palpite é apenas uma regra no compilador java. Por exemplo, o código a seguir retorna uma Lista <Inteiro []> Integer[] integerArray1 = { 1 }; Integer[] integerArray2 = { 2 }; List<Integer[]> integerArrays = Arrays.asList(integerArray1, integerArray2);
Simon
167

No Java 8, você pode usar fluxos:

int[] spam = new int[] { 1, 2, 3 };
Arrays.stream(spam)
      .boxed()
      .collect(Collectors.toList());
Ibrahim Arief
fonte
Isso é legal, mas não funciona boolean[]. Eu acho que é porque é tão fácil fazer um Boolean[]. Essa é provavelmente uma solução melhor. Enfim, é uma peculiaridade interessante.
GlenPeterson 21/02
138

Falando sobre a maneira de conversão, depende de por que você precisa do seu List. Se você precisar apenas para ler dados. OK, aqui vai você:

Integer[] values = { 1, 3, 7 };
List<Integer> list = Arrays.asList(values);

Mas se você fizer algo assim:

list.add(1);

você recebe java.lang.UnsupportedOperationException. Então, para alguns casos, você ainda precisa disso:

Integer[] values = { 1, 3, 7 };
List<Integer> list = new ArrayList<Integer>(Arrays.asList(values));

A primeira abordagem, na verdade, não converte a matriz, mas a 'representa' como a List. Mas a matriz está oculta com todas as suas propriedades, como número fixo de elementos. Observe que você precisa especificar o tipo ao construir ArrayList.

Roman Nikitchenko
fonte
1
"imutabilidade" me confundiu por um momento. Você pode obviamente alterar os valores da matriz. Você não pode alterar seu tamanho, no entanto.
precisa
125

O problema é que os varargs foram introduzidos no Java5 e, infelizmente, também Arrays.asList()foram sobrecarregados com uma versão do vararg. Assim Arrays.asList(spam), o compilador Java5 é entendido como um parâmetro vararg de matrizes int.

Esse problema é explicado em mais detalhes no Java Efetivo 2º Ed., Capítulo 7, Item 42.

Péter Török
fonte
4
Entendo o que aconteceu, mas não o porquê não está documentado. Estou procurando uma solução alternativa sem reimplementar a roda.
Alexandr
2
@UsmanIsmail No Java 8, podemos usar fluxos para essa conversão. Veja minha resposta abaixo .
Ibrahim Arief
109

Parece um pouco tarde, mas aqui estão meus dois centavos. Não podemos ter List<int>como inté um tipo primitivo, por isso só podemos terList<Integer> .

Java 8 (matriz int)

int[] ints = new int[] {1,2,3,4,5};
List<Integer> list11 =Arrays.stream(ints).boxed().collect(Collectors.toList()); 

Java 8 e abaixo (matriz inteira)

Integer[] integers = new Integer[] {1,2,3,4,5};
List<Integer> list21 =  Arrays.asList(integers); // returns a fixed-size list backed by the specified array.
List<Integer> list22 = new ArrayList<>(Arrays.asList(integers)); // good
List<Integer> list23 = Arrays.stream(integers).collect(Collectors.toList()); //Java 8 only

Precisa ArrayList e não List?

Caso desejemos uma implementação específica de, Listpor exemplo ArrayList, podemos usar toCollectioncomo:

ArrayList<Integer> list24 = Arrays.stream(integers)
                          .collect(Collectors.toCollection(ArrayList::new));

Por list21que não pode ser estruturalmente modificado?

Quando usamos Arrays.asListo tamanho da lista retornada, é corrigido porque a lista retornada não é java.util.ArrayList, mas uma classe estática privada definida dentro java.util.Arrays. Portanto, se adicionarmos ou removermos elementos da lista retornada, um UnsupportedOperationExceptionserá lançado. Portanto, devemos prosseguir list22quando queremos modificar a lista. Se tivermos o Java8, também podemos usar list23.

Para ser claro, list21pode ser modificado no sentido que podemos chamar, list21.set(index,element)mas esta lista não pode ser estruturalmente modificada, ou seja, não pode adicionar ou remover elementos da lista. Você também pode verificar esta pergunta .


Se queremos uma lista imutável, podemos agrupá-la como:

List<Integer> list 22 = Collections.unmodifiableList(Arrays.asList(integers));

Outro ponto a ser observado é que o método Collections.unmodifiableList retorna uma visão inalterável da lista especificada. Uma coleção de visualizações não modificáveis ​​é uma coleção que não pode ser modificada e também é uma exibição em uma coleção de suporte. Observe que as alterações na coleção de backup ainda podem ser possíveis e, se ocorrerem, serão visíveis na visualização não modificável.

Podemos ter uma lista realmente imutável no Java 9 e 10.

Lista verdadeiramente imutável

Java 9:

String[] objects = {"Apple", "Ball", "Cat"};
List<String> objectList = List.of(objects);

Java 10 (lista verdadeiramente imutável) de duas maneiras:

  1. List.copyOf(Arrays.asList(integers))
  2. Arrays.stream(integers).collect(Collectors.toUnmodifiableList());

Verifique também esta minha resposta para mais.

akhil_mittal
fonte
@BasilBourque, quis dizer, não pode modificar a estrutura da lista por adição / exclusão, mas pode alterar os elementos.
Akil_mittal
Na verdade, tentei algum código e confirmei que chamar List::adde List::removefalhar com uma lista retornada por Arrays.asList. O JavaDoc para esse método está mal escrito e não é claro neste ponto. Na minha terceira leitura, suponho que a frase "tamanho fixo" pretendesse dizer que não se pode adicionar ou remover elementos.
Basil Bourque
12

Ainda mais curto:

List<Integer> list = Arrays.asList(1, 2, 3, 4);
Vitaliy Sokolov
fonte
11

Recentemente, tive que converter uma matriz em uma lista. Posteriormente, o programa filtrou a lista tentando remover os dados. Ao usar a função Arrays.asList (matriz), você cria uma coleção de tamanho fixo: não é possível adicionar nem excluir. Esta entrada explica o problema da melhor maneira possível: Por que recebo uma UnsupportedOperationException ao tentar remover um elemento de uma Lista? .

No final, eu tive que fazer uma conversão "manual":

    List<ListItem> items = new ArrayList<ListItem>();
    for (ListItem item: itemsArray) {
        items.add(item);
    }

Suponho que eu poderia ter adicionado a conversão de uma matriz para uma lista usando uma operação List.addAll (itens).

Steve Gelman
fonte
11
new ArrayList<ListItem>(Arrays.asList(itemsArray))iria para o mesmo
Marco13
1
@BradyZhu: Concedida a resposta acima não resolve meu problema com a matriz de tamanho fixo, mas você está basicamente dizendo RTFM aqui, que é sempre uma forma ruim. Por favor, explique o que está errado com a resposta ou não se preocupe em comentar.
Steve Gelman
2
As ferramentas de inspeção podem mostrar um aviso aqui, e você nomeou o motivo. Não há necessidade de copiar os elementos manualmente, use em seu Collections.addAll(items, itemsArray)lugar.
precisa
Basta clicar nesta exceção. Receio que a resposta de Marco13 seja a resposta correta. Talvez eu precise ir embora o código do ano inteiro para corrigir todas as exceções "asList".
7

Usando matrizes

Essa é a maneira mais simples de converter uma matriz em List . No entanto, se você tentar adicionar um novo elemento ou remover um elemento existente da lista, um UnsupportedOperationExceptionserá lançado.

Integer[] existingArray = {1, 2, 3};
List<Integer> list1 = Arrays.asList(existingArray);
List<Integer> list2 = Arrays.asList(1, 2, 3);

// WARNING:
list2.add(1);     // Unsupported operation!
list2.remove(1);  // Unsupported operation!

Usando ArrayList ou outras implementações de lista

Você pode usar um forloop para adicionar todos os elementos da matriz em umList implementação, por exemplo ArrayList:

List<Integer> list = new ArrayList<>();
for (int i : new int[]{1, 2, 3}) {
  list.add(i);
}

Usando a API de Stream no Java 8

Você pode transformar a matriz em um fluxo e coletá-lo usando diferentes coletores: O coletor padrão no Java 8 usa ArrayList atrás da tela, mas também pode impor sua implementação preferida.

List<Integer> list1, list2, list3;
list1 = Stream.of(1, 2, 3).collect(Collectors.toList());
list2 = Stream.of(1, 2, 3).collect(Collectors.toCollection(ArrayList::new));
list3 = Stream.of(1, 2, 3).collect(Collectors.toCollection(LinkedList::new));

Veja também:

Mincong Huang
fonte
6

Outra solução alternativa se você usar o apache commons-lang:

int[] spam = new int[] { 1, 2, 3 };
Arrays.asList(ArrayUtils.toObject(spam));

Onde ArrayUtils.toObject converte int[]emInteger[]

alaster
fonte
5

você tem que usar a matriz

Arrays.asList((Object[]) array)
Giancarlo Frison
fonte
3
java: tipos incompatíveis: int [] não pode ser convertido em java.lang.Object []
dVaffection
@dVaffection Em seguida, converta para int []. Parte importante é converter para uma matriz.
Nebril 27/12/14
5

Uma linha:

List<Integer> list = Arrays.asList(new Integer[] {1, 2, 3, 4});
Bhushan
fonte
5

No Java 9, você tem a solução ainda mais elegante de usar listas imutáveis ​​por meio do novo método de fábrica de conveniência List.of:

List<String> immutableList = List.of("one","two","three");

(copiado descaradamente a partir daqui )

Pierluigi Vernetto
fonte
Para sua informação, para aprender alguns dos detalhes técnicos por trás disso, consulte JEP 269: Métodos de Fábrica de Conveniência para Coleções e uma palestra de Stuart Marks , o autor principal.
Basil Bourque 29/07
5

Se você está direcionando o Java 8 (ou posterior), pode tentar o seguinte:

int[] numbers = new int[] {1, 2, 3, 4};
List<Integer> integers = Arrays.stream(numbers)
                        .boxed().collect(Collectors.<Integer>toList());

NOTA:

Preste atenção ao Collectors.<Integer>toList(), esse método genérico ajuda a evitar o erro "Incompatibilidade de tipo: não é possível converter de List<Object>para List<Integer>".

nybon
fonte
4
  1. Usando a goiaba:

    Integer[] array = { 1, 2, 3};
    List<Integer> list = Lists.newArrayList(sourceArray);
  2. Usando coleções do Apache Commons:

    Integer[] array = { 1, 2, 3};
    List<Integer> list = new ArrayList<>(6);
    CollectionUtils.addAll(list, array);
Danail Tsvetanov
fonte
3

Se isso ajuda: Eu tive o mesmo problema e simplesmente escrevi uma função genérica que pega uma matriz e retorna um ArrayList do mesmo tipo com o mesmo conteúdo:

public static <T> ArrayList<T> ArrayToArrayList(T[] array) {
    ArrayList<T> list = new ArrayList<T>();
    for(T elmt : array) list.add(elmt);
    return list;
}
kleines filmröllchen
fonte
E se não ajudar? Então o que você fez? ... jk :)
Sᴀᴍ Onᴇᴌᴀ
2

Matriz fornecida:

    int[] givenArray = {2,2,3,3,4,5};

Convertendo matriz inteira em Lista inteira

Uma maneira: boxed () -> retorna o IntStream

    List<Integer> givenIntArray1 = Arrays.stream(givenArray)
                                  .boxed()
                                  .collect(Collectors.toList());

Segunda maneira: mapeie cada elemento do fluxo para Inteiro e depois colete

NOTA: Usando o mapToObj, você pode ocultar cada elemento int no fluxo de strings, no fluxo de caracteres, etc., encaixando i em (char) i

    List<Integer> givenIntArray2 = Arrays.stream(givenArray)
                                         .mapToObj(i->i)
                                         .collect(Collectors.toList());

Convertendo um tipo de matriz em outro tipo Exemplo:

List<Character> givenIntArray2 = Arrays.stream(givenArray)
                                             .mapToObj(i->(char)i)
                                             .collect(Collectors.toList());
Arpan Saini
fonte
1

Portanto, depende da versão do Java que você está tentando.

Java 7

 Arrays.asList(1, 2, 3);

OU

       final String arr[] = new String[] { "G", "E", "E", "K" };
       final List<String> initialList = new ArrayList<String>() {{
           add("C");
           add("O");
           add("D");
           add("I");
           add("N");
       }};

       // Elements of the array are appended at the end
       Collections.addAll(initialList, arr);

OU

Integer[] arr = new Integer[] { 1, 2, 3 };
Arrays.asList(arr);

No Java 8

int[] num = new int[] {1, 2, 3};
List<Integer> list = Arrays.stream(num)
                        .boxed().collect(Collectors.<Integer>toList())

Referência - http://www.codingeek.com/java/how-to-convert-array-to-list-in-java/

Hitesh Garg
fonte
1

Você pode melhorar esta resposta, por favor, pois é isso que eu uso, mas não estou 100% claro. Funciona bem, mas a inteligência adicionou uma nova WeatherStation [0]. Por que o 0?

    public WeatherStation[] removeElementAtIndex(WeatherStation[] array, int index)
    {
        List<WeatherStation> list = new ArrayList<WeatherStation>(Arrays.asList(array));
        list.remove(index);
        return list.toArray(new WeatherStation[0]);
    }

DevilCode
fonte
Por que devemos melhorar sua pergunta? Ou você sabe a resposta ou não. Obviamente, você deve fornecer uma resposta que realmente ajude os outros, e não uma que confunda mais do que ajuda.
HimBromBeere 19/01
-2

use duas linhas de código para converter a matriz em lista. Se você a usar em valor inteiro, deverá usar o tipo de caixa automática para o tipo de dados primitivo

  Integer [] arr={1,2};
  Arrays.asList(arr);
yousef
fonte