Erstellen Sie Arraylist von Array

StackOverflow https://stackoverflow.com/questions/157944

Frage

Ich habe ein Array, das wie initialisiert wird: 

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

Ich möchte dieses Array in ein Objekt der Klasse Arraylist konvertieren. 

ArrayList<Element> arraylist = ???;
War es hilfreich?

Lösung 

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

Andere Tipps

Gegeben: 

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

Die einfachste Antwort ist zu tun: 

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

Das funktioniert gut. Aber einige Einschränkungen:

  1. Die Liste von asList zurückgegeben hat feste Größe . Also, wenn Sie in der Lage sein wollen, Elemente aus der zurückgegebenen Liste in Ihrem Code hinzuzufügen oder zu entfernen, müssen Sie es in einem neuen ArrayList wickeln. Andernfalls erhalten Sie eine UnsupportedOperationException erhalten.
  2. Die Liste von asList() zurückgegeben wird, von dem ursprünglichen Array gesichert. Wenn Sie den Original-Array ändert, wird die Liste als auch modifiziert werden. Dies mag überraschend sein.

(alte Thread, aber nur 2 Cent wie keine Erwähnung Guava oder andere Libs und einige andere Details)

Wenn möglich, verwenden Sie Guava

Es lohnt sich, die Guava Weg wies darauf hin, das diese Spielereien stark vereinfacht:

Verwendung

Für eine unveränderliche Liste

Mit dem ImmutableList Klasse und ihr of() und Lists Klasse und ihr newArrayList() Factory-Methoden: 

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

Bitte beachten Sie auch die ähnlichen Methoden für andere Datenstrukturen in anderen Klassen, zum Beispiel in Sets .

Warum Guava?

Die Hauptattraktion könnte sein, die Unordnung zu reduzieren aufgrund Generika für Typsicherheit, da die Verwendung des Guava Arrays Klasse und seine asList() Factory-Methode, mit einem Collections.unmodifiableList() : 

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

, dass der zurück Typ für asList() ist ein List eine konkrete ArrayList Implementierung verwenden, aber Es ist nicht java.util.ArrayList. Es ist ein innerer Typ, der ein ArrayList emuliert, sondern tatsächlich verweist direkt auf die übergebene Array und macht es „write through“ (Änderungen in der Anordnung reflektiert werden).

Es verbietet Modifikationen durch einige der Methoden, die List API weise einfach eine AbstractList erstreckt (so, Hinzufügen oder Entfernen von Elementen wird nicht unterstützt), jedoch ermöglicht es Anrufe Elemente außer Kraft zu setzen, um set(). Somit ist diese Liste nicht wirklich unveränderlich und ein Aufruf an asList() sollte mit Collections.unmodifiableList() gewickelt werden.

Im nächsten Schritt, wenn Sie eine veränderbare Liste benötigen.

Für eine Veränderliche List

Wie oben, aber mit einem tatsächlichen java.util.ArrayList eingewickelt: 

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+

für pädagogische Zwecke: The Good ol‘Manual Way 

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

Da diese Frage ist ziemlich alt, es überrascht mich, dass niemand die einfachste Form vorgeschlagen noch: 

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

Wie von Java 5, Arrays.asList() nimmt einen varargs Parameter und Sie müssen nicht explizit das Array erstellen. 

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

Vergewissern Sie sich, dass myArray vom gleichen Typ wie T ist. Sie werden einen Compiler-Fehler, wenn Sie versuchen, eine List<Integer> aus einem Array von int zu schaffen, zum Beispiel.

Eine andere Art und Weise (obwohl im wesentlichen äquivalent zu der new ArrayList(Arrays.asList(array)) Lösung Performance-weise: 

Collections.addAll(arraylist, array);

Java 9

Java 9 , können Sie List.of statische Factory-Methode, um ein List wörtlich zu erstellen. Etwas wie folgt aus: 

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

Dies würde zurückkehren ein unveränderlich Liste enthält drei Elemente. Wenn Sie eine wandelbar Liste, übergeben Sie diese Liste des ArrayList Konstruktor: 

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

JEP 269: Convenience Factory-Methoden für Sammlungen

JEP 269 bietet einige Komfort Factory-Methoden für Java Collections API. Diese unveränderliche statische Factory-Methoden werden in den integrierten List Set und Map Schnittstellen in Java 9 und höher.

Sie müssen wahrscheinlich nur eine Liste, nicht eine Arraylist. In diesem Fall können Sie einfach tun: 

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

Ein weiteres Update, endet fast Jahr 2014 können Sie es tun mit Java 8 auch: 

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

Einige Zeichen würden gerettet werden, wenn dies nur ein List sein könnte 

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

Wenn Sie: 

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

Sie können erstellen und füllen zwei Listen! Füllen zweimal eine große Liste ist genau das, was Sie nicht wollen, zu tun, weil es die Kapazität erweitert werden eine andere Object[] Array jedes Mal schaffen muss.

Glücklicherweise ist die JDK-Implementierung ist schnell und Arrays.asList(a[]) ist sehr gut gemacht. Es schafft eine Art von Arraylist namens Arrays.ArrayList wo die Object [] Datenpunkte direkt mit dem 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
    }
    ....
}

Die gefährliche Seite ist, dass , wenn Sie die anfängliche Array ändern, können Sie die Liste ändern! Sind Sie sicher, dass Sie das wollen? ja vielleicht, vielleicht auch nicht.

Wenn nicht, ist die verständlichste Art und Weise, dies zu tun: 

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

Oder wie sagte @glglgl, können Sie eine weitere unabhängige Arraylist erstellen mit: 

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

Ich liebe Collections zu verwenden, Arrays oder Guave. Aber wenn es nicht passen, oder Sie fühlen es nicht, schreiben Sie einfach eine andere unelegant Linie statt.

In Java 9 können Sie: 

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

Nach der Frage der Antwort mit Java 1.7 ist: 

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

Allerdings ist es besser, immer die Schnittstelle verwenden: 

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

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

Sie können mit verschiedenen Methoden konvertieren

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

Für weitere Details können Sie sich auf http : //javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html

als alles gesagt dies so tut 

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

und die gemeinsame neueste Art und Weise Array zu erstellen ist observableArrays

ObservableList:. Eine Liste, die Zuhörer können Änderungen verfolgen, wenn sie auftreten

für Java SE können Sie versuchen, 

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

, die sich nach Oracle Docs

  

observableArrayList ()   Erzeugt eine neue leere beobachtbaren Liste, die von einem Arraylist unterstützt wird.   observableArrayList (E ... Artikel)   Erstellt eine neue beobachtbaren Array-Liste mit Artikeln zu hinzugefügt werden.

Update Java 9

auch in Java 9, es ist ein bisschen einfach: 

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

Sie können es auch mit Strom tun in Java 8. 

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

Da Java 8 gibt es eine einfachere Art und Weise zu transformieren: 

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

  1. Wenn wir die Definition von Arrays.asList() Methode sehen Sie so etwas wie diese: 

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

    Also, Sie könnten arraylist wie folgt initialisieren: 

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

    Hinweis . Jeder new Element(int args) wird als Einzelobjekt behandelt werden und kann als var-args weitergegeben werden

  2. Es könnte eine andere Antwort auf diese Frage sein.
    Wenn Sie Erklärung für java.util.Collections.addAll() Methode sehen Sie so etwas wie diese: 

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

    So ist dieser Code auch nützlich, dies zu tun 

    Collections.addAll(arraylist, array);

Eine weitere einfache Möglichkeit ist es, alle Elemente aus dem Array zu einem neuen Arraylist hinzuzufügen, unter Verwendung eine für-jede Schleife. 

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

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

Wenn das Array von einem primitiven Typ ist, werden die gegebenen Antworten nicht. Aber da Java 8 Sie verwenden können: 

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

Wir können leicht ein Array umwandeln ArrayList. Wir verwenden Collection-Schnittstelle des addAll() Verfahren zum Zwecke der das Kopieren von Inhalten von einer Liste in eine andere. 

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

Auch wenn es viele perfekt schriftlichen Antworten auf diese Frage sind, werde ich meine Eingaben hinzufügen.

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

New Arraylist kann auf folgende Weise erstellt werden 

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

Und sie sehr gut unterstützen alle Operationen von 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

Aber die folgenden Operationen gibt nur eine Listenansicht eines Arraylist und nicht unbedingt der 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));

Deshalb werden sie Fehler geben, wenn sie versuchen, einige Arraylist-Operationen zu machen 

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

Mehr auf Liste Darstellung von Array Link .

einfachste Weg, dies zu tun ist durch folgenden Code hinzufügen. Bewährt. 

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

Eine weitere Java8 Lösung (ich die Antwort unter dem großen Satz verpaßt habe. Wenn ja, meine Entschuldigung). Dies schafft eine Arraylist (im Gegensatz zu einer Liste im Gegensatz), dh ein Element löscht 

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

Die Ausgabe ist ...
Hallo
Welt

Sie können es in Java 8 wie folgt 

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

Schon jeder hat für Ihr Problem genug gute Antwort zur Verfügung gestellt. Jetzt von den alle Vorschläge, müssen Sie entschieden, welche Ihren Anforderungen passt. Es gibt zwei Arten von Sammlung, die Sie wissen müssen. Man ist nicht modifizierten Sammlung und andere Sammlung, die Sie das Objekt später ändern kann.

So, Hier werde ich kurz Beispiel für zwei Anwendungsfälle geben.

  • Immutable Sammlung Schaffung :: Wenn Sie nicht wollen, die Sammlung Objekt nach der Erstellung ändern

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

  • Mutable Sammlung Schaffung :: Wenn Sie möchten, können Sie die erstellte Sammlung Objekt nach der Erstellung ändern.

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

Mit dem folgenden Code, eine Element-Array in einen Arraylist konvertieren. 

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

Sie können eine ArrayList erstellen mit Cactoos (ich bin einer der Entwickler): 

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

Es gibt keine Garantie, dass das Objekt tatsächlich die Klasse ArrayList sein wird. Wenn Sie diese Garantie benötigen, dies zu tun: 

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

Verwenden Sie den folgenden Code 

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

Dies ist ein klarer Weg für die 

ArrayList<Element> arraylist = new ArrayList<>(Arrays.asList(array))
Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top