Crea ArrayList dall'array

Question

Ho un array inizializzato come:

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

Vorrei convertire questo array in un oggetto della classe ArrayList.

ArrayList<Element> arraylist = ???;

Answer 1

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

Answer 2

Data:

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.

Answer 3

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

Se puoi, usa Guava

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

Uso

Per un elenco immutabile

Utilizza <= > e la sua ImmutableList e of() metodi di fabbrica ^{(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 mutabile

Utilizza <= > e la sua copyOf() 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 Lists .

Perché Guava?

L'attrazione principale potrebbe essere quella di ridurre il disordine dovuto ai generici per la sicurezza dei tipi, come l'uso della Guava metodi di fabbrica consentono di dedurre i tipi la maggior parte delle volte. 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

Utilizza il newArrayList() del JDK e la sua < => metodo di fabbrica, racchiuso in un Sets :

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

Nota che il tipo restituito per Arrays è un asList() che usa un'implementazione concreta Collections.unmodifiableList(), ma NON è List. È un tipo interno, che emula un ArrayList ma in realtà fa direttamente riferimento all'array passato e lo rende & Quot; scrivi attraverso & Quot; (le modifiche si riflettono nella matrice).

Vieta le modifiche attraverso alcuni dei metodi dell'API java.util.ArrayList semplicemente estendendo un AbstractList (quindi, l'aggiunta o la rimozione di elementi non è supportata), tuttavia consente alle chiamate a set() di sovrascrivere gli elementi. Pertanto, questo elenco non è veramente immutabile e una chiamata a <=> deve essere racchiusa tra <=>.

Vedi il passaggio successivo se hai bisogno di un elenco mutabile.

Per un elenco mutabile

Come sopra, ma racchiuso in un <=>:

effettivo

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+

---

A scopo educativo: 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);
}

Answer 4

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.

Answer 5

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

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

Answer 6

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

Collections.addAll(arraylist, array);

Answer 7

Java 9

In Java 9 , puoi utilizzare List.of metodo statico di fabbrica per creare un <= > letterale. Qualcosa di simile al seguente:

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

Ciò restituirebbe un immutabile elenco contenente tre elementi. Se desideri un elenco mutabile , passa tale elenco al List costruttore:

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

---

JEP 269: Metodi della fabbrica di convenienza per le collezioni

JEP 269 fornisce alcuni metodi predefiniti di fabbrica per Collezioni Java API. Questi immutabili metodi statici di fabbrica sono integrati nel ArrayList , Set e Map in Java 9 e versioni successive .

Answer 8

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

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

Answer 9

Un altro aggiornamento, quasi conclusosi nel 2014, è possibile farlo anche con Java 8:

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

Alcuni caratteri verrebbero salvati, se questo fosse solo un List

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

Answer 10

Se si utilizza:

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

tu puoi creare e compilare due elenchi! 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 e Arrays.asList(a[]) è fatta molto bene. Crea una specie di ArrayList di nome 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 sì, 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'altra ArrayList indipendente con:

<*>

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

Answer 11

In Java 9 puoi usare:

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

Answer 12

Secondo la domanda la risposta usando 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);

Answer 13

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

Answer 14

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

Answer 15

come detto tutto ciò lo farà

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

e il modo più recente per creare un array è array osservabili

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

ovvero secondo Oracle Docs

  

observableArrayList ()   Crea un nuovo elenco osservabile vuoto supportato da un arraylist.   observableArrayList (E ... articoli)   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");

Answer 16

Puoi anche farlo con stream in Java 8.

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

Answer 17

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

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

Answer 18

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 arraylist in questo modo:

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

     

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

2. Potrebbe esserci un'altra risposta anche per questa domanda.
   Se vedi la dichiarazione per il metodo java.util.Collections.addAll() 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);
   

Answer 19

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

Answer 20

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

Answer 21

Possiamo facilmente convertire un array in ArrayList. Utilizziamo il metodo addAll() 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));

Answer 22

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

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

La nuova ArrayList può essere creata 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

Altre informazioni sulla rappresentazione dell'elenco dell'array link .

Answer 23

Il modo più semplice per farlo è quello di aggiungere il seguente codice. Provato e testato.

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

Answer 24

  

Un'altra soluzione Java8 (potrei aver perso la risposta tra il set di grandi dimensioni. In tal caso, le mie scuse). Questo crea un ArrayList (al contrario di un elenco), cioè è possibile 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

Answer 25

Puoi farlo in java 8 come segue

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

Answer 26

Già tutti hanno 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 seguito.

Quindi, qui farò 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 raccolte mutabili: quando si desidera modificare l'oggetto raccolta creato dopo la creazione.

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

Answer 27

Utilizzare il seguente codice 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]);
}

Answer 28

Puoi creare un ArrayList usando Cactoos (sono uno degli sviluppatori):

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

Non esiste alcuna garanzia che l'oggetto sarà effettivamente di classe <=>. Se hai bisogno di tale garanzia, esegui questa operazione:

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

Answer 29

Usa sotto il codice

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

Answer 30

Questo è un modo chiaro per quello

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