Convertendo array para lista em Java

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

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 .

No Java 8, você pode usar fluxos:

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

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.

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.

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.

Ainda mais curto:

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

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).

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:

• Por que usamos a caixa automática e a unboxing em Java?
• Quando usar o LinkedList sobre o ArrayList?

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[]

você tem que usar a matriz

Arrays.asList((Object[]) array)

Uma linha:

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

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 )

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>".

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

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

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

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/

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

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