Criar ArrayList de gama

Question

Eu tenho uma matriz que é inicializado como:

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

Gostaria de converter essa matriz em um objeto da classe ArrayList.

ArrayList<Element> arraylist = ???;

Answer 1

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

Answer 2

Dada:

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

A resposta mais simples é fazer:

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

Este belo trabalho vontade. Mas algumas ressalvas:

1. A lista retornada de asList tem tamanho fixo . Então, se você quer ser capaz de adicionar ou remover elementos da lista retornada no seu código, você precisa envolvê-la em uma nova ArrayList. Caso contrário, você vai ter uma UnsupportedOperationException.
2. A lista retornada de asList() é apoiado pela matriz original. Se você modificar a matriz original, a lista será modificado também. Isso pode ser surpreendente.

Answer 3

^{(discussão antiga, mas apenas 2 centavos como nenhum menção goiaba ou outros libs e alguns outros detalhes)}

Se puder, use Goiaba

É de salientar a forma como goiaba, o que simplifica essas travessuras:

Uso

Para uma lista Imutável

Use a ImmutableList classe e sua of() e copyOf() métodos de fábrica ^{(elementos não pode ser nulo)} :

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

Para obter uma lista mutável

Use a Lists classe e sua newArrayList() métodos de fábrica:

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

Observe também os métodos semelhantes para outras estruturas de dados em outras classes, por exemplo em Sets .

Por goiaba?

A principal atração pode ser o de reduzir a desordem devido aos genéricos para o Tipo-segurança, como o uso da Guava métodos de fábrica permitem os tipos de ser inferida a maior parte do tempo. No entanto, este argumento detém menos água desde Java 7 chegou com o novo operador de diamante.

Mas não é a única razão (e Java 7 não é em todos os lugares ainda): a sintaxe abreviada também é muito útil, e os initializers métodos, como visto acima, permitem escrever código mais expressivo. Você faz em uma chamada de goiaba que leva 2 com os atuais coleções de Java.

---

Se você não pode ...

Para uma lista Imutável

Arrays classe Uso do JDK e sua asList() método de fábrica, envolvida com uma Collections.unmodifiableList() :

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

Note que o tipo retornado para asList() é um List usando uma implementação concreta ArrayList, mas Não é java.util.ArrayList. É um tipo de interior, que emula um ArrayList mas na verdade faz referência direta a matriz passada e torna "write through" (modificações são refletidas na matriz).

Ela proíbe modificações através de alguns dos métodos a List da API por meio de simplesmente estender um AbstractList (assim, adicionando ou removendo elementos não é suportado), no entanto, permite que as chamadas para set() para elementos de substituição. Assim, esta lista não é verdadeiramente imutável e uma chamada para asList() devem ser embrulhados com Collections.unmodifiableList().

Veja o passo seguinte se você precisa de uma lista mutável.

Para obter uma lista mutável

O mesmo que acima, mas envolvido com uma 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: The Good ol' Way 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);
}

Answer 4

Uma vez que esta questão é muito velho, ele me surpreende que ninguém sugeriu a forma mais simples ainda:

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

A partir do Java 5, Arrays.asList() leva um varargs parâmetro e você não tem que construir a matriz explicitamente.

Answer 5

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

Certifique-se de que myArray é do mesmo tipo que T. Você obterá um erro do compilador se você tentar criar um List<Integer> entre uma variedade de int, por exemplo.

Answer 6

Uma outra forma (embora essencialmente equivalente à solução new ArrayList(Arrays.asList(array)) em termos de performance:

Collections.addAll(arraylist, array);

Answer 7

Java 9

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

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

Esta retornaria um imutável lista contendo três elementos. Se você quer uma mutável lista, passar essa lista para o construtor ArrayList:

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

---

PEC 269: métodos de fábrica de conveniência para coleções

PEC 269 fornece alguns métodos de conveniência de fábrica para Java Collections API. Estes métodos de fábrica estáticos imutáveis ??são incorporadas ao List , Set , e Map as interfaces em Java 9 e posterior.

Answer 8

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

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

Answer 9

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

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

Alguns personagens seriam salvos, se este poderia ser apenas um List

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

Answer 10

Se você usar:

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

você pode criar e preencher duas listas! Encher duas vezes uma grande lista é exatamente o que você não quer fazer porque vai criar outra matriz Object[] cada vez que as necessidades de capacidade para ser estendido.

Felizmente a implementação JDK é rápido e Arrays.asList(a[]) é muito bem feito. É criar uma espécie de ArrayList chamado Arrays.ArrayList onde o objeto [] pontos de dados diretamente para a matriz.

// 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ê muda a matriz inicial, você alterar a lista! Você tem certeza que quer isso? Talvez sim, talvez não.

Se não, a forma 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));

Gosto de usar Collections, Arrays, ou goiaba. Mas se ele não se encaixam, ou você não sente isso, basta escrever uma outra linha deselegante vez.

Answer 11

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

Answer 12

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

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

No entanto, é sempre melhor usar a interface:

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

Answer 13

// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray); 

Answer 14

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 a http : //javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html

Answer 15

como todos disseram isso vai fazê-lo

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

e a mais nova forma comum de criar matriz é observableArrays

ObservableList:. Uma lista que permite que os ouvintes para acompanhar as mudanças quando ocorrem

para Java SE você pode tentar

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

que está de acordo com a a Oracle Docs

observableArrayList () Cria uma nova lista observável vazio que é apoiado por um ArrayList. observableArrayList (E ... items) Cria uma nova lista de matriz observável com itens adicionados a ele.

Java Update 9

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

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

Answer 16

Você também pode fazê-lo com fluxo em Java 8.

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

Answer 17

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

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

Answer 18

1. Se formos ver a definição de método Arrays.asList() você terá algo parecido com isto:

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

   Assim, 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) vai ser tratado como objecto individual e pode ser transmitido como um var-args

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

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

   Assim, este código também é útil fazê-lo

   Collections.addAll(arraylist, array);
   

Answer 19

Outra forma simples é adicionar todos os elementos da matriz para um novo ArrayList usando um for-each loop.

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

for(Element e : array)
    list.add(e);

Answer 20

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

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

Answer 21

Podemos facilmente converter um array para ArrayList. Usamos método addAll() de interface de coleção com a finalidade de copiar o conteúdo de uma lista para outra.

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

Answer 22

Embora existam muitas respostas perfeitamente escritos a esta pergunta, vou acrescentar minhas entradas.

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

New ArrayList pode ser criado no seguinte maneiras

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 muito bem suportar todas as operações de 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 seguintes retorna apenas uma exibição de lista de um ArrayList real ArrayList e não.

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

Por isso, 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 representação Lista de gama ligação .

Answer 23

Mais simples maneira de fazer isso é através da adição de código a seguir. Experimentado e testado.

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

Answer 24

Outra solução Java8 (eu possa ter perdido a resposta entre o grande conjunto. Se assim for, as minhas desculpas). Isto cria um ArrayList (em oposição a uma lista), ou seja se pode 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);
    }
}

A saída é ...
Olá
world

Answer 25

Você pode fazer isso em java 8 como segue

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

Answer 26

Já todos forneceu resposta boa o suficiente para o seu problema. Agora, a partir das 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 coleta não modificada e outra coleção um que lhe permitirá modificar o objeto mais tarde.

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

• criação coleção Imutável :: Quando você não quiser modificar o objeto de coleção após a criação

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

  |

• criação coleta Mutante :: Quando você pode querer modificar o objeto coleção criada após a criação.

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

  |

Answer 27

Use o seguinte código para converter uma matriz elemento em um 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]);
}

Answer 28

Você pode criar um 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 vai ser realmente de ArrayList classe. Se você precisar essa garantia, faça o seguinte:

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

Answer 29

Use o código abaixo

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

Answer 30

Esta é uma maneira clara para que

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