java - example - Erstellen Sie ArrayList aus Array




java arraylist to array (20)

Ich habe ein Array, das wie folgt initialisiert wird:

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

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

ArrayList<Element> arraylist = ???;

Eine andere Java8-Lösung (Ich habe die Antwort unter den großen Sets möglicherweise verpasst. Wenn ja, entschuldige ich mich). Dadurch wird eine ArrayList erstellt (im Gegensatz zu einer Liste), dh man kann Elemente löschen

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

Ausgabe ist ...
Hallo
Welt


Java 9

In Java 9 können Sie die statische Factory-Methode List.of verwenden, um ein List Literal zu erstellen. Etwas wie das Folgende:

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

Dies würde eine immutable Liste mit drei Elementen zurückgeben. Wenn Sie eine veränderliche Liste wünschen, übergeben Sie diese Liste an den ArrayList Konstruktor:

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

JEP 269: Convenience Factory-Methoden für Sammlungen

JEP 269 bietet einige praktische Factory-Methoden für die Java Collections- API. Diese unveränderlichen statischen Factory-Methoden sind in Java 9 und höher in die Schnittstellen List , Set und Map integriert.


Am einfachsten ist es, folgenden Code hinzuzufügen. Ausprobiert und getestet.

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

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

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

Ab Java 5 benötigt Arrays.asList() einen varargs-Parameter, und Sie müssen das Array nicht explizit erstellen.


Eine andere Möglichkeit (obwohl im Wesentlichen gleichbedeutend mit der new ArrayList(Arrays.asList(array)) Lösung new ArrayList(Arrays.asList(array)) -Lösung new ArrayList(Arrays.asList(array)) :

Collections.addAll(arraylist, array);

Eine andere einfache Möglichkeit besteht darin, alle Elemente aus dem Array mit einer for-each-Schleife zu einer neuen ArrayList hinzuzufügen.

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

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

Gegeben:

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

Benutzen:

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

Gegeben:

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

Die einfachste Antwort lautet:

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

Das wird gut funktionieren. Aber einige Vorbehalte:

  1. Die von asList zurückgegebene Liste hat eine feste Größe . Wenn Sie also Elemente zur zurückgegebenen Liste in Ihrem Code hinzufügen oder daraus entfernen möchten, müssen Sie sie in eine neue ArrayList . Andernfalls erhalten Sie eine UnsupportedOperationException .
  2. Die von asList() zurückgegebene Liste wird vom ursprünglichen Array unterstützt. Wenn Sie das ursprüngliche Array ändern, wird auch die Liste geändert. Das kann überraschend sein.

Jeder hat schon genug gute Antwort auf Ihr Problem gegeben. Nun müssen Sie aus allen Vorschlägen herausfinden, welche Ihren Anforderungen entsprechen. Es gibt zwei Arten von Sammlungen, die Sie kennen müssen. Eine ist eine unveränderte Sammlung und eine andere Sammlung, mit der Sie das Objekt später ändern können.

Hier werde ich ein kurzes Beispiel für zwei Anwendungsfälle geben.

  • Erstellung unveränderlicher Sammlungen: Wenn Sie das Sammlungsobjekt nach der Erstellung nicht ändern möchten

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

  • Erstellung einer veränderlichen Sammlung: Wenn Sie das erstellte Sammlungsobjekt nach der Erstellung ändern möchten.

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


Obwohl es viele perfekt geschriebene Antworten auf diese Frage gibt, werde ich meine Eingaben hinzufügen.

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

Neue 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 unterstützen sehr gut 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

Die folgenden Vorgänge geben jedoch nur eine Listenansicht einer ArrayList und keine tatsächliche ArrayList zurück.

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

Daher wird ein Fehler ausgegeben, wenn versucht wird, einige ArrayList-Vorgänge auszuführen

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

Mehr zu Listendarstellung der Array- link .


Sie benötigen wahrscheinlich nur eine Liste, keine ArrayList. In diesem Fall können Sie einfach Folgendes tun:

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

Sie können dies auch mit Stream in Java 8 tun.

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

Sie können dies leicht mit Hilfe von Arrays.asList (arrayObj) tun.

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


Wenn du benutzt :

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

Sie können zwei Listen erstellen und ausfüllen ! Wenn Sie zweimal eine große Liste ausfüllen, ist dies genau das, was Sie nicht tun möchten, da jedes Mal ein Object[] Array erstellt wird, wenn die Kapazität erweitert werden muss.

Glücklicherweise ist die JDK-Implementierung schnell und Arrays.asList(a[]) ist sehr gut gemacht. Es erstellt eine Art ArrayList mit dem Namen Arrays.ArrayList, bei der die Object [] - Daten direkt auf das Array zeigen.

// 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 Sie die Liste ändern , wenn Sie das ursprüngliche Array ändern. Bist du dir sicher, dass du das willst? Vielleicht ja vielleicht nein.

Wenn nicht, ist der verständlichste Weg 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 gesagt @glglgl, können Sie eine andere unabhängige ArrayList erstellen mit:

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

Ich benutze gerne Collections , Arrays oder Guaven. Wenn es aber nicht passt oder Sie es nicht fühlen, schreiben Sie stattdessen eine andere unausgewählte Zeile.


Wir können ein Array leicht in ArrayList konvertieren. Wir verwenden die addAll() Methode der Collection-Schnittstelle zum Kopieren von Inhalten von einer Liste in eine andere.

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

(alter Thread, aber nur 2 Cent, da keiner Guava oder andere Libs und einige andere Details erwähnt)

Wenn Sie können, verwenden Sie Guave

Es lohnt sich, auf den Guaven-Weg hinzuweisen, der diese Phänomene erheblich vereinfacht:

Verwendungszweck

Für eine unveränderliche Liste

Verwenden Sie die ImmutableList Klasse und die Factory-Methoden of() und copyOf() (Elemente dürfen nicht null sein) :

List<String> il = ImmutableList.of("string", "elements");  // from varargs
List<String> il = ImmutableList.copyOf(aStringArray);      // from array

Für eine veränderliche Liste

Verwenden Sie die Lists Klasse und ihre Factory-Methoden newArrayList() :

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

Beachten Sie auch die ähnlichen Methoden für andere Datenstrukturen in anderen Klassen, beispielsweise in Sets .

Warum Guave?

Die Hauptattraktion könnte darin bestehen, die Unordnung aufgrund von Generika für die Typsicherheit zu reduzieren, da durch die Verwendung der Guava-Werksmethoden die meisten Arten auf die Typen geschlossen werden können. Dieses Argument hält jedoch weniger Wasser, seit Java 7 mit dem neuen Diamantenoperator eingetroffen ist.

Dies ist jedoch nicht der einzige Grund (und Java 7 ist noch nicht überall): Die Abkürzungssyntax ist auch sehr praktisch, und die Methodeninitialisierer (siehe oben) ermöglichen das Schreiben von ausdrucksvollerem Code. Sie machen in einem Guava-Aufruf, was 2 mit den aktuellen Java-Sammlungen dauert.

Wenn du nicht kannst ...

Für eine unveränderliche Liste

Verwenden Sie die Arrays Klasse des JDK und seine Factory-Methode asList() , die mit einer Collections.unmodifiableList() umhüllt ist:

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

Beachten Sie, dass der zurückgegebene Typ für asList() eine List , die eine konkrete ArrayList Implementierung verwendet, jedoch NICHT java.util.ArrayList . Hierbei handelt es sich um einen inneren Typ, der eine ArrayList emuliert, tatsächlich jedoch direkt auf das übergebene Array verweist und es "durchschreiben" lässt (Änderungen werden im Array wiedergegeben).

Es verbietet Änderungen an einigen Methoden der List API, indem einfach eine AbstractList (das Hinzufügen oder Entfernen von Elementen wird jedoch nicht unterstützt). Aufrufe von set() jedoch überschrieben werden. Daher ist diese Liste nicht wirklich unveränderlich und ein Aufruf von asList() sollte mit Collections.unmodifiableList() umhüllt werden.

Siehe den nächsten Schritt, wenn Sie eine veränderliche Liste benötigen.

Für eine veränderliche Liste

Wie oben, jedoch mit einer aktuellen java.util.ArrayList umhüllt:

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: Der gute alte Weg

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

Um ein Array in eine ArrayList zu konvertieren, führen Entwickler häufig Folgendes aus:

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

Arrays.asList() gibt eine ArrayList zurück, die eine private static class inside Arrays ist. Es ist nicht die Klasse java.util.ArrayList. The java.util.Arrays.ArrayList Klasse hat set(), get(), contains() Methoden set(), get(), contains() , verfügt jedoch über keine Methoden zum Hinzufügen von Elementen. Daher ist ihre Größe festgelegt. Um eine echte ArrayList zu erstellen, müssen Sie Folgendes tun:

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

Der Konstruktor von ArrayList kann einen Collection-Typ akzeptieren, der auch ein Supertyp für java.util.Arrays.ArrayList


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

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




type-conversion