Domanda Crea ArrayList dall'array


Ho una matrice che è inizializzata come:

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

Mi piacerebbe convertire questa matrice in un oggetto della classe ArrayList.

ArrayList<Element> arraylist = ???;

2962
2017-10-01 14:38


origine


risposte:


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

3961
2017-10-01 14:39



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

Questo funzionerà bene. Ma alcuni avvertimenti:

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

773
2017-10-01 15:39



(vecchio thread, ma solo 2 centesimi perché nessuno menziona Guava o altre librerie e altri dettagli)

Se puoi, usa Guava

Vale la pena sottolineare la modalità Guava, che semplifica enormemente questi shenanigans:

uso

Per una lista immutabile

Usa il ImmutableList classe e il suo of() e copyOf() 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 una lista mutevole

Usa il Lists classe e il suo 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

Si prega di notare anche i metodi simili per altre strutture di dati in altre classi, per 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 di Guava metodi di fabbrica consenti ai tipi di essere dedotti il ​​più delle volte. Tuttavia, questo argomento contiene meno acqua da quando Java 7 è arrivato con il nuovo operatore di diamante.

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


Se non puoi ...

Per una lista immutabile

Usa i JDK Arrays classe e il suo asList() metodo di fabbrica, avvolto con a 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 List usando un cemento ArrayList implementazione, ma non è  java.util.ArrayList. È un tipo interiore, che emula un ArrayList ma in realtà fa riferimento direttamente all'array passato e lo rende "write through" (le modifiche si riflettono nell'array).

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

Vedi il prossimo passo se hai bisogno di una lista mutabile.

Per una lista mutevole

Come sopra, ma avvolto con un reale 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);
}

294
2017-11-16 17:16



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 esplicitamente.


202
2018-06-22 11:30



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

Assicurati che myArray è lo stesso tipo di T. Avrai un errore del compilatore se proverai a creare un List<Integer>da una serie di int, per esempio.


172
2017-10-01 14:40



Un altro modo (anche se essenzialmente equivalente al new ArrayList(Arrays.asList(array)) prestazioni della soluzione:

Collections.addAll(arraylist, array);

76
2018-04-03 23:20



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

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

62
2017-10-01 14:45



Java 9

In Java 9, Puoi usare List.of metodo statico di fabbrica per creare a List letterale. Qualcosa come il seguente:

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

Ciò restituirebbe un immutabile lista contenente tre elementi. Se vuoi un mutevole lista, passare quella lista al ArrayList costruttore:

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

JEP 269: Metodi di fabbrica convenienti per le collezioni

JEP 269 fornisce alcuni metodi di fabbrica convenienti per Collezioni Java API. Questi metodi di fabbrica statici immutabili sono incorporati nel List, Set, e Map interfacce in Java 9 e versioni successive.


59
2018-04-17 16:58



Un altro aggiornamento, quasi concluso l'anno 2014, puoi farlo anche con Java 8:

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

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

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

54
2017-11-25 20:48



Per convertire un array in ArrayList, gli sviluppatori spesso lo fanno:

List<String> list = Arrays.asList(arr);// this is wrong way..

Arrays.asList() restituirà un ArrayList che è un private static class inside Arrays, non è la classe java.util.ArrayList. The java.util.Arrays.ArrayList la classe ha set(), get(), contains() metodi, ma non ha metodi per aggiungere elementi, quindi la sua dimensione è fissa. Per creare una vera ArrayList, devi fare:

ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr));

Il costruttore di ArrayList può accettare a Tipo di raccolta, che è anche un tipo super per java.util.Arrays.ArrayList


47
2018-06-25 07:20