A conversão de matriz para lista em Java

Question

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

Eu usei o Arrays.asList() mas o comportamento (e assinatura) de alguma forma mudou a partir do Java SE 1.4.2 (docs agora em arquivo) 8 e a maioria dos trechos que eu encontrei na web, use o 1.4.2 comportamento.

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
• no 1.5.0+ devolve uma lista que contém a matriz de spam

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

Assert.assertTrue(Arrays.asList(spam).indexOf(4) == -1);

Answer 1

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

Você pode, no entanto, ter um List<Integer> usando o Integer classe que envolve o int primitivo. Converter sua matriz em um List com o Arrays.asList Método de utilidade.

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

Veja isso Código execute ao vivo em ideone.com.

Answer 2

No Java 8, você pode usar fluxos:

int[] spam = new int[] { 1, 2, 3 };
Arrays.stream(spam)
      .boxed()
      .collect(Collectors.toList());

Answer 3

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 está:

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

Mas então se você fizer algo assim:

list.add(1);

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

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

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

Answer 4

O problema é que as varargs foram introduzidas no Java5 e, infelizmente, Arrays.asList() Também fiquei sobrecarregado com uma versão vararja. Então Arrays.asList(spam) é entendido pelo compilador Java5 como um parâmetro vararg das matrizes int.

Esse problema é explicado em mais detalhes em Java 2ª ed., Capítulo 7, Item 42.

Answer 5

Parece um pouco tarde, mas aqui estão meus dois centavos. Não podemos ter List<int> Como int é um tipo primitivo, então só podemos ter List<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 de Arraylist e não listar?

Caso queremos uma implementação específica de List por exemplo ArrayList Então podemos usar toCollection Como:

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

---

Por que list21 não pode ser estruturalmente modificado?

Quando usamos Arrays.asList O tamanho da lista retornado é corrigido porque a lista retornada não é java.util.ArrayList, mas uma classe estática privada definida dentro java.util.Arrays. Então, se adicionarmos ou removermos elementos da lista retornada, um UnsupportedOperationException será jogado. Então devemos ir com list22 Quando queremos modificar a lista. Se tivermos Java8, então também podemos ir com list23.

Para ser claro list21 pode ser modificado no sentido que podemos ligar list21.set(index,element) Mas essa lista pode não ser modificada estruturalmente, o IE não pode adicionar ou remover elementos da lista. Você também pode verificar isso pergunta.

---

Se queremos uma lista imutável, podemos embrulhá -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 não modificável da lista especificada. Uma coleção de visualização não modificável é uma coleção que não é modificável e também é uma exibição em uma coleção de apoio. Observe que as alterações na coleção de apoio ainda podem ser possíveis e, se ocorrerem, são visíveis através da visão não modificável.

Podemos ter uma lista verdadeiramente imutável em Java 10.

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 isso responda do meu para mais.

Answer 6

Recentemente, tive que converter uma matriz em uma lista. Posteriormente, o programa filtrou a lista tentando remover os dados. Quando você usa a função Arrays.asList (Array), você cria uma coleção de tamanho fixo: você não pode adicionar nem excluir. Esta entrada explica o problema melhor do que eu: Por que recebo um UnsupportEdOperationException ao tentar remover um elemento de uma lista?.

No final, 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 conversão de uma matriz em uma lista usando uma list.addall (itens) operação.

Answer 7

Ainda mais curto:

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

Answer 8

Usando matrizes

Esta é a maneira mais simples de converter uma matriz para List. No entanto, se você tentar adicionar um novo elemento ou remover um elemento existente da lista, um UnsupportedOperationException será jogado.

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 o ArrayList ou outras implementações de lista

Você pode usar um for loop para adicionar todos os elementos da matriz em um List 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 fluxo em Java 8

Você pode transformar a matriz em um fluxo e depois coletar o fluxo usando diferentes colecionadores: o coletor padrão em Java 8 Use ArrayList Atrás da tela, mas você 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:

• Por que usamos Autoboxing e Unboxing em Java?
• Quando usar o LinkedList sobre o ArrayList?

Answer 9

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 convertidos int[] para Integer[]

Answer 10

Em Java 9 você tem a solução ainda mais elegante de usar imutável listas através do novo conveniência método de fábrica List.of:

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

(descaradamente copiado do aqui )

Answer 11

Se você está segmentando o Java 8 (ou mais tarde), pode tentar o seguinte:

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

NOTA:

Prestar atenção à Collectors.<Integer>toList(), esse método genérico ajuda você a evitar o erro "Tipo incompatível: não pode se converter de List<Object> para List<Integer>".

Answer 12

você tem que lançar para o arranjo

Arrays.asList((Object[]) array)

Answer 13

One-liner:

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

Answer 14

1. Usando goiaba:

   Integer[] array = { 1, 2, 3};
   List<Integer> list = Lists.newArrayList(sourceArray);
   

2. Usando as coleções do Apache Commons:

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

Answer 15

Então depende de qual versão java 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);

Em Java 8

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

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

Answer 16

Se isso ajudar: tive o mesmo problema e simplesmente escrevi uma função genérica que pega uma matriz e devolve uma lista 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;
}

Answer 17

Dada a matriz:

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

Converter matriz inteira em lista inteira

One Way: 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 coletar

NOTA: Usando o Maptoobj, você pode encobrir cada elemento int em String Stream, Char Stream etc por Casing I para (char) I

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

Convertendo um tipo de matriz em outro exemplo de tipo:

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

Answer 18

Use duas linhas de código para converter a matriz para listar se você o usar em valor inteiro, você deve usar o tipo de auto -espionagem para o tipo de dados primitivo

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