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