Crea ArrayList dall'array
-
03-07-2019 - |
Domanda
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 = ???;
Soluzione
new ArrayList<>(Arrays.asList(array))
Altri suggerimenti
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:
- 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 unUnsupportedOperationException
. - 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 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 <=>:
effettivoList<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);
}
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 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.
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 , 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 .
Probabilmente hai solo bisogno di un Elenco, non di un ArrayList. In tal caso puoi semplicemente fare:
List<Element> arraylist = Arrays.asList(array);
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());
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.
In Java 9
puoi 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 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);
// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray);
Puoi convertire usando diversi metodi
-
List<Element> list = Arrays.asList(array);
-
List<Element> list = new ArrayList();
Collections.addAll(list, array); -
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
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");
Puoi anche farlo con stream in Java 8.
List<Element> elements = Arrays.stream(array).collect(Collectors.toList());
Da Java 8 esiste un modo più semplice per trasformare:
public static <T> List<T> fromArray(T[] array) {
return Arrays.stream(array).collect(toList());
}
-
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 comevar-args
. -
Potrebbe esserci un'altra risposta anche per questa domanda.
Se vedi la dichiarazione per il metodojava.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);
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());
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));
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 .
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));
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
Puoi farlo in java 8 come segue
ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());
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));
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]);
}
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"
)
);
Usa sotto il codice
Element[] array = {new Element(1), new Element(2), new Element(3)};
ArrayList<Element> list = (ArrayList) Arrays.asList(array);
Questo è un modo chiaro per quello
ArrayList<Element> arraylist = new ArrayList<>(Arrays.asList(array))