Criar ArrayList da matriz

Eu tenho uma matriz que é inicializada como:

Element[] array = {new Element(1), new Element(2), new Element(3)}; 

Eu gostaria de converter essa matriz em um object da class ArrayList.

 ArrayList arraylist = ???; 

     new ArrayList<>(Arrays.asList(array)) 

    Dado:

     Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) }; 

    A resposta mais simples é fazer:

     List list = Arrays.asList(array); 

    Isso vai funcionar bem. Mas algumas ressalvas:

    1. A lista retornada de asList tem tamanho fixo . Portanto, se você quiser adicionar ou remover elementos da lista retornada em seu código, precisará envolvê-lo em uma nova ArrayList . Caso contrário, você receberá uma UnsupportedOperationException .
    2. A lista retornada de asList() é apoiada pela matriz original. Se você modificar o array original, a lista também será modificada. Isso pode ser surpreendente.

    (thread antigo, mas apenas 2 centavos, como nenhuma menção a goiaba ou outras libs e alguns outros detalhes)

    Se você puder, use Goiaba

    Vale a pena destacar o caminho da goiaba, o que simplifica bastante essas travessuras:

    Uso

    Para uma lista imutável

    Use a class ImmutableList e seus methods de fábrica of() e copyOf() (elementos não podem ser nulos) :

     List il = ImmutableList.of("string", "elements"); // from varargs List il = ImmutableList.copyOf(aStringArray); // from array 

    Para uma lista mutável

    Use a class Lists e seus methods factory newArrayList() :

     List l1 = Lists.newArrayList(anotherListOrCollection); // from collection List l2 = Lists.newArrayList(aStringArray); // from array List l3 = Lists.newArrayList("or", "string", "elements"); // from varargs 

    Por favor, observe também os methods similares para outras estruturas de dados em outras classs, por exemplo, em Sets .

    Por que goiaba?

    A principal atração poderia ser reduzir a desordem devido a genéricos para segurança de tipo, já que o uso dos methods da fábrica de Guava permite que os tipos sejam inferidos a maior parte do tempo. No entanto, este argumento tem menos água desde que o Java 7 chegou com o novo operador de diamante.

    Mas não é a única razão (e o Java 7 ainda não está em todo lugar): a syntax abreviada também é muito útil, e os inicializadores de methods, como visto acima, permitem escrever código mais expressivo. Você faz em uma chamada Guava o que leva 2 com as Coleções Java atuais.


    Se você não pode …

    Para uma lista imutável

    Use a class Arrays do JDK e seu método factory asList() com um Collections.unmodifiableList() :

     List l1 = Collections.unmodifiableList(Arrays.asList(anArrayOfElements)); List l2 = Collections.unmodifiableList(Arrays.asList("element1", "element2")); 

    Observe que o tipo retornado para asList() é uma List usando uma implementação ArrayList concreta, mas NÃO é java.util.ArrayList . É um tipo interno, que emula um ArrayList mas na verdade faz referência direta ao array passado e o faz “escrever através de” (as modificações são refletidas no array).

    Ele proíbe modificações por meio de alguns dos methods da API List , simplesmente estendendo um AbstractList (assim, adicionar ou remover elementos não é suportado), no entanto, ele permite que chamadas para set() substituam elementos. Portanto, essa lista não é verdadeiramente imutável e uma chamada para asList() deve ser empacotada com Collections.unmodifiableList() .

    Veja o próximo passo se você precisar de uma lista mutável.

    Para uma lista mutável

    O mesmo que acima, mas envolvido com um java.util.ArrayList real:

     List l1 = new ArrayList(Arrays.asList(array)); // Java 1.5 to 1.6 List l1b = new ArrayList<>(Arrays.asList(array)); // Java 1.7+ List l2 = new ArrayList(Arrays.asList("a", "b")); // Java 1.5 to 1.6 List l2b = new ArrayList<>(Arrays.asList("a", "b")); // Java 1.7+ 

    Para fins educacionais: a boa e velha maneira manual

     // for Java 1.5+ static  List arrayToList(final T[] array) { final List l = new ArrayList(array.length); for (final T s : array) { l.add(s); } return (l); } // for Java < 1.5 (no generics, no compile-time type-safety, boo!) static List arrayToList(final Object[] array) { final List l = new ArrayList(array.length); for (int i = 0; i < array.length; i++) { l.add(array[i]); } return (l); } 

    Como essa pergunta é bem antiga, me surpreende que ninguém tenha sugerido a forma mais simples:

     List arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3)); 

    A partir do Java 5, Arrays.asList() usa um parâmetro varargs e você não precisa construir o array explicitamente.

     new ArrayList(Arrays.asList(myArray)); 

    Certifique-se de que myArray seja do mesmo tipo que T Você receberá um erro do compilador se tentar criar um List partir de uma matriz de int , por exemplo.

    Outra maneira (embora essencialmente equivalente à new ArrayList(Arrays.asList(array)) solução new ArrayList(Arrays.asList(array)) desempenho:

     Collections.addAll(arraylist, array); 

    Você provavelmente só precisa de uma lista, não uma ArrayList. Nesse caso, você pode apenas fazer:

     List arraylist = Arrays.asList(array); 

    Java 9

    No Java 9 , você pode usar o método de fábrica List.of estático para criar um literal de List . Algo como o seguinte:

     List elements = List.of(new Element(1), new Element(2), new Element(3)); 

    Isso retornaria uma lista imutável contendo três elementos. Se você quiser uma lista mutável , passe essa lista para o construtor ArrayList :

     new ArrayList<>(List.of(// elements vararg)) 

    JEP 269: Métodos de Fábrica de Conveniência para Coleções

    O JEP 269 fornece alguns methods de fábrica de conveniência para a API de Coleções Java . Esses methods de fábrica estáticos imutáveis ​​são construídos nas interfaces List , Set e Map no Java 9 e posterior.

    Outra atualização, quase terminando o ano de 2014, você pode fazê-lo com o Java 8 também:

     ArrayList arrayList = Stream.of(myArray).collect(Collectors.toCollection(ArrayList::new)); 

    Alguns caracteres seriam salvos, se isso pudesse ser apenas uma List

     List list = Stream.of(myArray).collect(Collectors.toList()); 

    Para converter uma matriz em uma ArrayList, os desenvolvedores geralmente fazem isso:

     List list = Arrays.asList(arr);// this is wrong way.. 

    Arrays.asList() retornará um ArrayList que é uma private static class inside Arrays , não é a class java.util.ArrayList. The java.util.Arrays.ArrayList class The java.util.Arrays.ArrayList possui methods set(), get(), contains() , mas não possui methods para adicionar elementos, portanto, seu tamanho é fixo. Para criar uma ArrayList real, você deve fazer:

     ArrayList arrayList = new ArrayList(Arrays.asList(arr)); 

    O construtor de ArrayList pode aceitar um tipo Collection , que também é um tipo super para java.util.Arrays.ArrayList

    Se você usar :

     new ArrayList(Arrays.asList(myArray)); 

    você pode criar e preencher duas listas! Preencher duas vezes uma lista grande é exatamente o que você não deseja fazer porque criará outro array Object[] toda vez que a capacidade precisar ser estendida.

    Felizmente, a implementação do JDK é rápida e o Arrays.asList(a[]) é muito bem feito. Ele cria um tipo de ArrayList chamado Arrays.ArrayList onde os dados de Object [] apontam diretamente para o array.

     // in Arrays @SafeVarargs public static  List asList(T... a) { return new ArrayList<>(a); } //still in Arrays, creating a private unseen class private static class ArrayList private final E[] a; ArrayList(E[] array) { a = array; // you point to the previous array } .... } 

    O lado perigoso é que, se você alterar o array inicial, você muda a lista! Tem certeza que quer isso? Talvez sim talvez não.

    Se não, a maneira mais compreensível é fazer isso:

     ArrayList list = new ArrayList(myArray.length); // you know the initial capacity for (Element element : myArray) { list.add(element); } 

    Ou como disse @glglgl, você pode criar outro ArrayList independente com:

     new ArrayList(Arrays.asList(myArray)); 

    Adoro usar Collections , Arrays ou goiaba. Mas se não se encheckbox, ou você não sente, apenas escreva outra linha deselegante em seu lugar.

    No Java 9 você pode usar:

     List list = List.of("Hello", "World", "from", "Java"); List list = List.of(1, 2, 3, 4, 5); 

    De acordo com a pergunta, a resposta usando o java 1.7 é:

     ArrayList arraylist = new ArrayList(Arrays.asList(array)); 

    No entanto, é melhor sempre usar a interface:

     List arraylist = Arrays.asList(array); 
     // Guava import com.google.common.collect.ListsLists ... List list = Lists.newArrayList(aStringArray); 

    Você pode converter usando methods diferentes

    1. List list = Arrays.asList(array);

    2. List list = new ArrayList();
      Collections.addAll(list, array);

    3. Arraylist list = new Arraylist();
      list.addAll(Arrays.asList(array));

    Para mais detalhes, você pode consultar http://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html

    Você também pode fazer isso com stream no Java 8.

      List elements = Arrays.stream(array).collect(Collectors.toList()); 

    Desde o Java 8, existe uma maneira mais fácil de transformar:

     public static  List fromArray(T[] array) { return Arrays.stream(array).collect(toList()); } 
    1. Se nós vermos a definição do método Arrays.asList() você terá algo assim:

        public static  List asList(T... a) //varargs are of T type. 

      Então, você pode inicializar arraylist assim:

        List arraylist = Arrays.asList(new Element(1),new Element(2),new Element(3)); 

      Nota : cada new Element(int args) será tratado como Objeto Individual e pode ser passado como um var-args .

    2. Pode haver outra resposta para essa pergunta também.
      Se você ver declaração para o método java.util.Collections.addAll() , você terá algo assim:

       public static  boolean addAll(Collection< ? super T> c, T... a); 

      Então, esse código também é útil para fazer isso

       Collections.addAll(arraylist, array); 

    Outra maneira simples é adicionar todos os elementos da matriz a uma nova ArrayList usando um loop for-each.

     ArrayList list = new ArrayList<>(); for(Element e : array) list.add(e); 

    como tudo dito isso vai fazê-lo

      new ArrayList<>(Arrays.asList(array)) 

    e a maneira mais recente comum de criar array é observableArrays

    ObservableList: Uma lista que permite que os ouvintes acompanhem as alterações quando elas ocorrem.

    para Java SE você pode tentar

     FXCollections.observableArrayList(new Element(1), new Element(2), new Element(3)); 

    isso é de acordo com o Oracle Docs

    observableArrayList () Cria uma nova lista observável vazia que é suportada por uma arraylist. observableArrayList (E … itens) Cria uma nova lista de matriz observável com itens adicionados a ela.

    Atualize o Java 9

    também no Java 9 é um pouco fácil:

     List list = List.of("element 1", "element 2", "element 3"); 

    Dado:

     Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) }; 

    Usar:

     List listArray = Arrays.asList(array); 

    Se a matriz for de um tipo primitivo, as respostas dadas não funcionarão. Mas desde o Java 8 você pode usar:

     int[] array = new int[5]; Arrays.stream(array).boxed().collect(Collectors.toList()); 

    Mesmo que haja muitas respostas perfeitamente escritas para essa pergunta, adicionarei minhas inputs.

    Digamos que você tenha Element[] array = { new Element(1), new Element(2), new Element(3) };

    New ArrayList pode ser criado das seguintes formas

     ArrayList arraylist_1 = new ArrayList<>(Arrays.asList(array)); ArrayList arraylist_2 = new ArrayList<>( Arrays.asList(new Element[] { new Element(1), new Element(2), new Element(3) })); // Add through a collection ArrayList arraylist_3 = new ArrayList<>(); Collections.addAll(arraylist_3, array); 

    E eles suportam muito bem todas as operações da ArrayList

     arraylist_1.add(new Element(4)); // or remove(): Success arraylist_2.add(new Element(4)); // or remove(): Success arraylist_3.add(new Element(4)); // or remove(): Success 

    Mas as operações a seguir retornam apenas uma visualização de lista de uma ArrayList e não uma ArrayList real.

     // Returns a List view of array and not actual ArrayList List listView_1 = (List) Arrays.asList(array); List listView_2 = Arrays.asList(array); List listView_3 = Arrays.asList(new Element(1), new Element(2), new Element(3)); 

    Portanto, eles vão dar erro ao tentar fazer algumas operações ArrayList

     listView_1.add(new Element(4)); // Error listView_2.add(new Element(4)); // Error listView_3.add(new Element(4)); // Error 

    Mais sobre a representação da lista de link da matriz.

    Podemos facilmente converter uma matriz para ArrayList . Usamos o método addAll() da Collection Collection para copiar conteúdo de uma lista para outra.

      Arraylist arr = new Arraylist(); arr.addAll(Arrays.asList(asset)); 

    A maneira mais simples de fazer isso é adicionando o código a seguir. Tentei e testei.

     String[] Array1={"one","two","three"}; ArrayList s1= new ArrayList(Arrays.asList(Array1)); 

    Outra solução Java8 (eu posso ter perdido a resposta entre o grande conjunto. Se assim for, minhas desculpas). Isso cria um ArrayList (em oposição a uma lista), ou seja, pode-se excluir elementos

     package package org.something.util; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class Junk { static  ArrayList arrToArrayList(T[] arr){ return Arrays.asList(arr) .stream() .collect(Collectors.toCollection(ArrayList::new)); } public static void main(String[] args) { String[] sArr = new String[]{"Hello", "cruel", "world"}; List ret = arrToArrayList(sArr); // Verify one can remove an item and print list to verify so ret.remove(1); ret.stream() .forEach(System.out::println); } } 

    Saída é …
    Olá
    mundo

    Todos já deram resposta suficiente para o seu problema. Agora, a partir de todas as sugestões, você precisa decidir qual vai caber sua exigência. Existem dois tipos de coleção que você precisa saber. Uma é a coleção não modificada e outra coleção que lhe permitirá modificar o object mais tarde.

    Então, aqui vou dar um breve exemplo para dois casos de uso.

    • Criação de coleção imutável: quando você não quer modificar o object de coleção após a criação

      List elementList = Arrays.asList(array)

    • Criação de coleção mutável :: Quando você pode querer modificar o object de coleção criado após a criação.

      List elementList = new ArrayList(Arrays.asList(array));

    Você pode fazê-lo em java 8 da seguinte forma

     ArrayList list = (ArrayList)Arrays.stream(array).collect(Collectors.toList()); 
      Element[] array = {new Element(1), new Element(2), new Element(3)}; List elements=Arrays.asList(array); 

    Você pode criar um ArrayList usando Cactoos (eu sou um dos desenvolvedores):

     List names = new StickyList<>( "Scott Fitzgerald", "Fyodor Dostoyevsky" ); 

    Não há garantia de que o object será realmente da class ArrayList . Se você precisar dessa garantia, faça o seguinte:

     ArrayList list = new ArrayList<>( new StickyList<>( "Scott Fitzgerald", "Fyodor Dostoyevsky" ) );