Am o matrice care este inițializat, cum ar fi:
Element[] array = {new Element(1), new Element(2), new Element(3)};
Aș dori pentru a converti această matrice într-un obiect din clasa ArrayList.
ArrayList<Element> arraylist = ???;
Având în vedere:
Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };
Răspunsul cel mai simplu este sa faci:
List<Element> list = Arrays.asList(array);
Aceasta va funcționa bine. Dar unele limitări:
ArrayList
. Altfel'll o UnsupportedOperationException
.asList()
este susținută de matrice inițială. Dacă modificați matrice inițială, lista va fi modificat la fel de bine. Acest lucru poate fi surprinzător. (thread vechi, dar doar 2 cenți ca nici unul nu mai vorbim de Guava sau alte libs și alte detalii)
L's valoare de subliniind Guava fel, care simplifică foarte mult aceste comice:
Folosi ImmutableList
clasă și a()
și copyOf()
fabrica de metode (elemente pot't fi null):
List<String> il = ImmutableList.of("string", "elements"); // from varargs
List<String> il = ImmutableList.copyOf(aStringArray); // from array
Folosi Liste
clasă și newArrayList()
fabrica de metode:
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
Vă rugăm să rețineți, de asemenea, metode similare pentru alte structuri de date în alte clase, de exemplu în Seturi
.
Principalul punct de atractie ar putea fi pentru a reduce dezordinea din cauza generice de tip siguranță, ca utilizarea de Guava fabrica de metode permite ca tipurile să fie dedusă cele mai multe ori. Cu toate acestea, acest argument deține mai puțin de apă din Java 7 a sosit cu noul diamant operator.
Dar's nu este singurul motiv (și Java 7 e't peste tot încă): scurtătura sintaxa este, de asemenea, foarte la îndemână, și metode de initializare, cum am văzut mai sus, permite să se scrie mai mult cod expresiv. Ai face într-o singură Guava apel ce durează 2 cu actualele Colecții Java.
Utilizarea JDK's Tablouri
clasă și asList()
metoda fabrica, înfășurat cu un Colecții.unmodifiableList()
:
List<String> l1 = Collections.unmodifiableList(Arrays.asList(anArrayOfElements));
List<String> l2 = Collections.unmodifiableList(Arrays.asList("element1", "element2"));
Rețineți că s-a întors tipul de asList()e o "Listă" cu ajutorul unui beton
ArrayList în aplicare, dar NU java.util.ArrayList
. L's un interior de tip, care emulează un ArrayList` dar de fapt direct referințe la trecut matrice și o face "scrie" (modificările sunt reflectate în matrice).
Se interzice modificări prin unele din "Lista" API's metode prin simpla extindere o AbstractList
(deci, adăugarea sau eliminarea de elemente este de neacceptat), cu toate acestea, se permite apeluri să set()
pentru a înlocui elementele. Astfel, această listă nu este't cu adevărat imuabil și un apel la asList()
ar trebui să fie înfășurat cu Colectiile.unmodifiableList()`.
Vezi următorul pas dacă aveți nevoie de un mutabil lista.
La fel ca mai sus, dar înfășurat cu o real 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+
// 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);
}
Deoarece această întrebare este destul de vechi, mă surprinde că nimeni nu a sugerat cea mai simplă formă încă:
List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));
Ca de Java 5, Matrice.asList()
ia o varargs parametru și nu't au de a construi matrice în mod explicit.
În Java 9, puteți utiliza Lista.a
metoda statica fabrică în scopul de a crea o "Listă" de literal. Ceva de genul următor:
List<Element> elements = List.of(new Element(1), new Element(2), new Element(3));
Acest lucru ar reveni un imuabil listă care conține trei elemente. Dacă doriți un mutabil lista, trece această listă ArrayList
constructor:
new ArrayList<>(List.of(// elements vararg))
JEP 269 oferă un confort fabrica de metode pentru Colecții Java API. Aceste imuabil metode fabrică statice sunt construite în Lista
, Stabilit
, și Harta
interfețe în Java 9 și mai târziu.
Un alt update, aproape de finalul anului 2014, o poti face cu Java 8:
ArrayList<Element> arrayList = Stream.of(myArray).collect(Collectors.toCollection(ArrayList::new));
Câteva personaje-ar fi salvat, dacă acest lucru ar putea fi doar o "Listă"
List<Element> list = Stream.of(myArray).collect(Collectors.toList());
Dacă utilizați :
new ArrayList<T>(Arrays.asList(myArray));
ai poate crea și umple două liste ! Umplere de două ori o listă mare este exact ceea ce ai nu't vreau să fac pentru că se va crea un alt Obiect[]` matrice de fiecare dată de capacitatea trebuie să fie extinsă.
Din fericire JDK aplicare este rapid și Tablouri.asList(a[])` este foarte bine făcut. Se crea un fel de ArrayList numit Matrice.ArrayList unde Object[] puncte de date direct de la matrice.
// 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
}
....
}
Partea periculoasă e care dacă schimbați inițială matrice, puteți modifica Lista ! Ești sigur că vrei asta ? Poate da, poate nu.
Dacă nu, cel mai ușor de înțeles este de a face acest lucru :
ArrayList<Element> list = new ArrayList<Element>(myArray.length); // you know the initial capacity
for (Element element : myArray) {
list.add(element);
}
Sau cum a spus @glglgl, puteți crea un alt independent ArrayList cu :
new ArrayList<T>(Arrays.asList(myArray));
Îmi place să folosesc "Colecții", Matrice
, sau Guava. Dar dacă don't se potrivesc, sau tu nu't simt, doar scrie un alt neelegant linie în loc.
În conformitate cu întrebarea răspunsul folosind java 1.7 este:
ArrayList<Element> arraylist = new ArrayList<Element>(Arrays.<Element>asList(array));
Cu toate acestea, de's întotdeauna mai bine de a folosi interfata:
List<Element> arraylist = Arrays.<Element>asList(array);
Puteți converti folosind diferite metode
Lista
Lista
Arraylist list = new Arraylist(); lista.addAll(Tablouri.asList(array));
Pentru mai multe detalii puteți consulta http://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html
ca tot spus acest lucru o va face
new ArrayList<>(Arrays.asList("1","2","3","4"));
și comune mai nou mod de a crea matrice este observableArrays
ObservableList: O listă care vă permite ascultătorilor să urmăriți modificările atunci când acestea apar.
pentru Java SE, puteți încerca
FXCollections.observableArrayList(new Element(1), new Element(2), new Element(3));
care este potrivit Oracle Docs
observableArrayList() Creează un nou gol observabil lista, care este susținută de un arraylist. observableArrayList(E... de articole) Creează un nou observabile listă matrice cu elemente adăugate la acesta.
de asemenea, în Java 9 l's un pic mai ușor:
List<String> list = List.of("element 1", "element 2", "element 3");
Deoarece Java 8 există o cale mai ușoară de a transforma:
public static <T> List<T> fromArray(T[] array) {
return Arrays.stream(array).collect(toList());
}
public static
Deci, s-ar putea inițializa arraylist
astfel:
Listă
Notă : fiecare nou Element(int args)
va fi tratat ca un Obiect Individual și poate fi trecut ca un
var-args`.
public static
Colecții.addAll(arraylist, matrice);
Dacă o matrice este de un tip primitiv, dat răspunsuri câștigat't de lucru. Dar din moment Java 8, puteți folosi:
int[] array = new int[5];
Arrays.stream(array).boxed().collect(Collectors.toList());