ti-enxame.com

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 objeto da classe ArrayList.

ArrayList<Element> arraylist = ???;
3198
Ron Tuffin
new ArrayList<>(Arrays.asList(array))
4212
Tom

Dado:

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

A resposta mais simples é fazer:

List<Element> list = Arrays.asList(array);

Isso vai funcionar bem. Mas algumas ressalvas:

  1. A lista retornada de asList possui fixed size . Portanto, se você quiser adicionar ou remover elementos da lista retornada em seu código, será necessário envolvê-lo em um novo ArrayList. Caso contrário, você receberá um UnsupportedOperationException.
  2. A lista retornada de asList() é respaldada pela matriz original. Se você modificar o array original, a lista também será modificada. Isso pode ser surpreendente. 
824
Alex Miller

(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 classe ImmutableList e seus métodos of() e copyOf() factory (elementos não podem ser nulos):

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

Para uma lista mutável

Use os métodos Lists e its newArrayList() factory:

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

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

Por que goiaba?

A atração principal poderia ser reduzir a desordem devido a genéricos para segurança de tipo, como o uso do Guava métodos de fábrica permite os tipos ser inferidos a maioria do tempo. No entanto, este argumento tem menos água desde que o Java 7 chegou com o novo operador de diamantes.

Mas não é a única razão (e o Java 7 ainda não está em todo lugar): a sintaxe abreviada também é muito útil, e os inicializadores de métodos, 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 classe Arrays do JDK e seu método asList() factory, empacotado com um Collections.unmodifiableList() :

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

Observe que o tipo retornado para asList() é um List usando uma implementação concreta de ArrayList, mas it NOTJava.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 métodos da API List simplesmente estendendo um AbstractList (portanto, adicionar ou remover elementos não é suportado), no entanto, ele permite que chamadas set() substituam elementos. Portanto, essa lista não é verdadeiramente imutável e uma chamada para asList() deve ser envolvida 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<String> l1  = new ArrayList<String>(Arrays.asList(array));    // Java 1.5 to 1.6
List<String> l1b = new ArrayList<>(Arrays.asList(array));          // Java 1.7+
List<String> l2  = new ArrayList<String>(Arrays.asList("a", "b")); // Java 1.5 to 1.6
List<String> l2b = new ArrayList<>(Arrays.asList("a", "b"));       // Java 1.7+

Para fins educacionais: a boa e velha maneira manual

// for Java 1.5+
static <T> List<T> arrayToList(final T[] array) {
  final List<T> l = new ArrayList<T>(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);
}
311
haylem

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

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

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

210
Tim Büthe
new ArrayList<T>(Arrays.asList(myArray));

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

183
Bill the Lizard

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

Collections.addAll(arraylist, array);
83
Peter Tseng

Java 9

Em Java 9 , você pode usar o método List.of static factory para criar um literal List. Algo como o seguinte:

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

Isso retornaria uma lista imutable 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

JEP 269 fornece alguns métodos de fábrica de conveniência para Java Collections API. Esses métodos de fábrica estáticos imutáveis ​​são construídos nas interfaces List , Set , e Map no Java 9 e posterior.

72
Ali Dehghani

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

List<Element> arraylist = Arrays.asList(array);
66
Kip

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

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

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

List<Element> list = Stream.of(myArray).collect(Collectors.toList());
56
whyem

Se você usar :

new ArrayList<T>(Arrays.asList(myArray));

você maio criar e preencher duas listas! Preencher duas vezes uma lista grande é exatamente o que você não quer fazer porque criará outro array Object[] cada 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 <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}
//still in Arrays, creating a private unseen class
private static class ArrayList<E>

    private final E[] a;    
    ArrayList(E[] array) {
        a = array; // you point to the previous array
    }
    ....
}

O lado perigoso é que se você mudar 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<Element> list = new ArrayList<Element>(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<T>(Arrays.asList(myArray));

Adoro usar Collections, Arrays ou Guava. Mas se não se encaixa, ou você não sente, apenas escreva outra linha deselegante.

31
Nicolas Zozol

Em Java 9 você pode usar:

List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);
28
MarekM

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

ArrayList<Element> arraylist = new ArrayList<Element>(Arrays.<Element>asList(array));

No entanto, é melhor sempre usar a interface:

List<Element> arraylist = Arrays.<Element>asList(array);
25
nekperu15739
// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray); 
21
Bohdan

Você pode converter usando métodos diferentes

  1. List<Element> list = Arrays.asList(array);

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

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

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

17
oxy_js

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

 List<Element> elements = Arrays.stream(array).collect(Collectors.toList()); 
14
Vaseph

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

public static <T> List<T> fromArray(T[] array) {
    return Arrays.stream(array).collect(toList());
}
14
Andrii Abramov

como tudo dito isso vai fazê-lo 

 new ArrayList<>(Arrays.asList("1","2","3","4"));

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 Oracle Docs

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

Atualizar o Java 9

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

List<String> list = List.of("element 1", "element 2", "element 3");
14
Abojemyeg
  1. Se nós vermos a definição do método Arrays.asList() você terá algo assim: 

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

    Então, você pode inicializar arraylist assim: 

     List<Element> 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 var-args.

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

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

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

    Collections.addAll(arraylist, array);
    
10
Vikrant Kashyap

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

ArrayList<Element> list = new ArrayList<>();

for(Element e : array)
    list.add(e);
8
spencer.sm

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

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

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

Use o código a seguir para converter uma matriz de elementos em uma ArrayList. 

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

ArrayList<Element>elementArray=new ArrayList();
for(int i=0;i<array.length;i++) {
    elementArray.add(array[i]);
}
4
TG Kavinda Pushpitha

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

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

New ArrayList pode ser criado das seguintes formas

ArrayList<Element> arraylist_1 = new ArrayList<>(Arrays.asList(array));
ArrayList<Element> arraylist_2 = new ArrayList<>(
    Arrays.asList(new Element[] { new Element(1), new Element(2), new Element(3) }));

// Add through a collection
ArrayList<Element> 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<Element> listView_1 = (List<Element>) Arrays.asList(array);
List<Element> listView_2 = Arrays.asList(array);
List<Element> 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 de lista de matriz link .

4
Devendra Lattu

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

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

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 <T> ArrayList<T>  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<String> 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

3
Toothless Seer

Você pode fazê-lo no Java 8 da seguinte forma

ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());
3
Adit A. Pillai

Todos já deram resposta suficiente para o seu problema. Agora, a partir de todas as sugestões, você precisa decidir qual vai se adequar à 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 objeto 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 objeto de coleção após a criação

    List<Element> elementList = Arrays.asList(array)

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

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

2
Sumit Das

Use abaixo o código

Element[] array = {new Element(1), new Element(2), new Element(3)};
ArrayList<Element> list = (ArrayList) Arrays.asList(array);
1
Devratna

Este é um caminho claro para isso

ArrayList<Element> arraylist = new ArrayList<>(Arrays.asList(array))
1
Hasee Amarathunga

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

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

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

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

A classe Arrays do Java 8 fornece um método stream () que possui versões sobrecarregadas, aceitando tanto arrays primitivos quanto arrays Object.

/**** Converting a Primitive 'int' Array to List ****/

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

List<Integer> integerList1 = Arrays.stream(intArray).boxed().collect(Collectors.toList());

/**** 'IntStream.of' or 'Arrays.stream' Gives The Same Output ****/

List<Integer> integerList2 = IntStream.of(intArray).boxed().collect(Collectors.toList());

/**** Converting an 'Integer' Array to List ****/

Integer integerArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

List<Integer> integerList3 = Arrays.stream(integerArray).collect(Collectors.toList());
0
Himanshu Dave