Ho un array inizializzato come:

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

Vorrei convertire questo array in un oggetto della ArrayListclasse.

ArrayList<Element> arraylist = ???;

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

Dato:

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

La risposta più semplice è fare:

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

Funzionerà benissimo. Ma alcuni avvertimenti:

1. L'elenco restituito da asList ha dimensioni fisse . Quindi, se vuoi essere in grado di aggiungere o rimuovere elementi dall'elenco restituito nel tuo codice, dovrai racchiuderlo in un nuovo ArrayList. Altrimenti otterrai un UnsupportedOperationException.
2. L'elenco restituito da asList()è supportato dall'array originale. Se si modifica l'array originale, anche l'elenco verrà modificato. Questo può essere sorprendente.

^{(vecchio thread, ma solo 2 centesimi poiché nessuno menziona Guava o altre librerie e altri dettagli)}

Se puoi, usa Guava

Vale la pena sottolineare il modo Guava, che semplifica notevolmente questi shenanigans:

uso

Per un elenco immutabile

Usa la ImmutableListclasse e i suoi metodi of()e copyOf()factory ^{(gli elementi non possono essere nulli)} :

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

Per un elenco mutevole

Usa la Listsclasse e i suoi newArrayList()metodi di fabbrica:

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

Nota anche metodi simili per altre strutture di dati in altre classi, ad esempio in Sets.

Perché guava

L'attrazione principale potrebbe essere quella di ridurre il disordine dovuto ai generici per la sicurezza del tipo, come l'uso dei metodi di fabbrica della Guava consente di dedurre i tipi per la maggior parte del tempo. Tuttavia, questo argomento contiene meno acqua da quando Java 7 è arrivato con il nuovo operatore Diamond.

Ma non è l'unico motivo (e Java 7 non è ancora dappertutto): anche la sintassi abbreviata è molto utile e gli inizializzatori dei metodi, come visto sopra, consentono di scrivere codice più espressivo. Fai in una chiamata Guava ciò che richiede 2 con le attuali Collezioni Java.

Se non puoi ...

Per un elenco immutabile

Usa la Arraysclasse JDK e il suo asList()metodo factory, racchiuso in un Collections.unmodifiableList():

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

Si noti che il tipo restituito per asList()è un'implementazione Listconcreta che ArrayListutilizza, ma NON lo è java.util.ArrayList . È un tipo interiore, che emula unArrayList ma in realtà fa direttamente riferimento all'array passato e lo fa "scrivere attraverso" (le modifiche si riflettono nell'array).

Proibisce modifiche attraverso alcuni dei Listmetodi dell'API semplicemente estendendo un AbstractList(quindi, l'aggiunta o la rimozione di elementi non è supportata), tuttavia consente alle chiamate set()di sovrascrivere gli elementi. Quindi questa lista non è veramente immutabile e asList()dovrebbe essere racchiusa una chiamata a Collections.unmodifiableList().

Vedere il passaggio successivo se è necessario un elenco modificabile.

Per un elenco mutevole

Come sopra, ma avvolto con un effettivo java.util.ArrayList:

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+

Per scopi educativi: il buon vecchio modo manuale

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

Poiché questa domanda è piuttosto vecchia, mi sorprende che nessuno abbia ancora suggerito la forma più semplice:

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

A partire da Java 5, Arrays.asList()accetta un parametro varargs e non è necessario costruire l'array in modo esplicito.

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

Assicurati che myArraysia dello stesso tipo di T. Riceverai un errore del compilatore se provi a creare un List<Integer>da una matrice di int, ad esempio.

Un altro modo (sebbene sostanzialmente equivalente alla new ArrayList(Arrays.asList(array))soluzione dal punto di vista delle prestazioni:

Collections.addAll(arraylist, array);

Java 9

In Java 9 , è possibile utilizzare il List.ofmetodo factory statico per creare un valore Listletterale. Qualcosa di simile al seguente:

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

Ciò restituirebbe un elenco immutabile contenente tre elementi. Se si desidera un mutabile lista, passare tale elenco per il ArrayListcostruttore:

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

JEP 269: Metodi di fabbrica di convenienza per le collezioni

JEP 269 fornisce alcuni metodi predefiniti per l' API Java Collections . Questi metodi factory statici immutabili sono costruiti nelle List, Sete Mapinterfacce in Java 9 e versioni successive.

Probabilmente hai solo bisogno di un elenco, non di un array. In tal caso puoi semplicemente fare:

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

Un altro aggiornamento, quasi terminante all'anno 2014, è possibile farlo anche con Java 8:

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

Alcuni personaggi verrebbero salvati, se questo potesse essere solo un List

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

Se usi:

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

si può creare e compilare due liste! Compilare due volte un grande elenco è esattamente ciò che non si desidera fare perché creerà un altro Object[]array ogni volta che è necessario estendere la capacità.

Fortunatamente l'implementazione di JDK è veloce ed Arrays.asList(a[])è fatta molto bene. Crea un tipo di ArrayList chiamato Arrays.ArrayList in cui i dati Object [] puntano direttamente all'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
    }
    ....
}

Il lato pericoloso è che se si modifica l'array iniziale, si modifica l'elenco! Sei sicuro di volerlo? Forse si forse no.

In caso contrario, il modo più comprensibile è farlo:

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

O come detto @glglgl, puoi creare un altro ArrayList indipendente con:

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

Mi piace usare Collections, Arrayso Guava. Ma se non si adatta o non lo senti, scrivi invece un'altra riga non elegante.

In Java 9puoi usare:

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

Secondo la domanda, la risposta che utilizza java 1.7 è:

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

Comunque è meglio usare sempre l'interfaccia:

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

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

È possibile convertire utilizzando diversi metodi

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

Per maggiori dettagli puoi consultare http://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html

come detto tutto ciò lo farà

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

e il modo più recente per creare array è osservableArrays

ObservableList: un elenco che consente agli ascoltatori di tenere traccia delle modifiche quando si verificano.

per Java SE puoi provare

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

questo è secondo Oracle Docs

observableArrayList () Crea un nuovo elenco osservabile vuoto supportato da un arraylist. observableArrayList (E ... items) Crea un nuovo elenco di array osservabili con gli elementi aggiunti ad esso.

Aggiorna Java 9

anche in Java 9 è un po 'semplice:

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

Da Java 8 esiste un modo più semplice per trasformare:

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

Puoi anche farlo con stream in Java 8.

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

1. Se vediamo la definizione di Arrays.asList()metodo otterrai qualcosa del genere:

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

   Quindi, potresti inizializzare in arraylistquesto modo:

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

   Nota : ognuno new Element(int args)verrà trattato come un singolo oggetto e può essere passato come un var-args.

2. Potrebbe esserci un'altra risposta anche per questa domanda.
   Se vedi la dichiarazione per il java.util.Collections.addAll()metodo otterrai qualcosa del genere:

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

   Quindi, questo codice è utile anche per farlo

   Collections.addAll(arraylist, array);

Un altro modo semplice è quello di aggiungere tutti gli elementi dell'array a un nuovo ArrayList usando un ciclo for-each.

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

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

Se l'array è di tipo primitivo, le risposte fornite non funzioneranno. Ma da Java 8 puoi usare:

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

Puoi farlo in Java 8 come segue

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

Possiamo facilmente convertire un array in ArrayList . Utilizziamo il addAll()metodo dell'interfaccia di raccolta allo scopo di copiare il contenuto da un elenco a un altro.

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

Anche se ci sono molte risposte perfettamente scritte a questa domanda, aggiungerò i miei input.

Di 'che hai Element[] array = { new Element(1), new Element(2), new Element(3) };

New ArrayList può essere creato nei seguenti modi

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 supportano molto bene tutte le operazioni di 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

Ma le seguenti operazioni restituiscono solo una vista Elenco di un ArrayList e non un vero ArrayList.

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

Pertanto, verranno visualizzati errori quando si tenta di eseguire alcune operazioni ArrayList

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

Ulteriori informazioni sulla rappresentazione in elenco dei collegamenti di array .

Il modo più semplice per farlo è aggiungendo il seguente codice. Provato e testato.

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

Un'altra soluzione Java8 (potrei aver perso la risposta tra il grande set. In tal caso, le mie scuse). Questo crea un ArrayList (al contrario di un Elenco), cioè uno può eliminare elementi

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

L'output è ...
Ciao
mondo

Utilizzare il codice seguente per convertire un array di elementi in un 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]);
}

Tutti hanno già fornito una risposta abbastanza buona per il tuo problema. Da tutti i suggerimenti, è necessario decidere quale si adatta alle proprie esigenze. Esistono due tipi di raccolta che è necessario conoscere. Uno è una raccolta non modificata e l'altra una raccolta che ti permetterà di modificare l'oggetto in un secondo momento.

Quindi, qui darò un breve esempio per due casi d'uso.

• Creazione di raccolte immutabili :: Quando non si desidera modificare l'oggetto raccolta dopo la creazione

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

• Creazione di raccolta mutabile :: Quando si desidera modificare l'oggetto raccolta creato dopo la creazione.

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

Dato array di oggetti:

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

Converti array in elenco:

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

Converti array in array

    ArrayList<Element> arrayList = Arrays.stream(array)
                                       .collect(Collectors.toCollection(ArrayList::new));

Converti array in LinkedList

    LinkedList<Element> linkedList = Arrays.stream(array)
                     .collect(Collectors.toCollection(LinkedList::new));

Stampa elenco:

    list.forEach(element -> {
        System.out.println(element.i);
    });

PRODUZIONE

1

2

3

La classe Arrays di Java 8 fornisce un metodo stream () che ha versioni sovraccaricate che accettano sia array primitivi che 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());

Di seguito il codice sembra un buon modo per farlo.

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