Konvertieren eines Arrays in eine Liste in Java

Wie konvertiere ich ein Array in eine Liste in Java?

Ich habe das verwendet, Arrays.asList()aber das Verhalten (und die Signatur) haben sich irgendwie von Java SE 1.4.2 (Dokumente jetzt im Archiv) auf 8 geändert , und die meisten Snippets, die ich im Web gefunden habe, verwenden das Verhalten 1.4.2.

Zum Beispiel:

int[] spam = new int[] { 1, 2, 3 };
Arrays.asList(spam)

• on 1.4.2 gibt eine Liste mit den Elementen 1, 2, 3 zurück
• on 1.5.0+ gibt eine Liste mit dem Array-Spam zurück

In vielen Fällen sollte es leicht zu erkennen sein, aber manchmal kann es unbemerkt verrutschen:

Assert.assertTrue(Arrays.asList(spam).indexOf(4) == -1);

In Ihrem Beispiel liegt dies daran, dass Sie keine Liste eines primitiven Typs haben können. Mit anderen Worten List<int>ist nicht möglich.

Sie können haben jedoch eine List<Integer>die Verwendung von IntegerKlasse, die die Packungen intprimitiv. Konvertieren Sie Ihr Array Listmit der Arrays.asListUtility-Methode in a.

Integer[] spam = new Integer[] { 1, 2, 3 };
List<Integer> list = Arrays.asList(spam);

Sehen Sie diesen Code live auf IdeOne.com .

In Java 8 können Sie Streams verwenden:

int[] spam = new int[] { 1, 2, 3 };
Arrays.stream(spam)
      .boxed()
      .collect(Collectors.toList());

Wenn Sie über die Konvertierungsmethode sprechen, hängt es davon ab, warum Sie Ihre benötigen List. Wenn Sie es nur zum Lesen von Daten benötigen. Ok, hier hast du es:

Integer[] values = { 1, 3, 7 };
List<Integer> list = Arrays.asList(values);

Aber wenn Sie so etwas tun:

list.add(1);

du bekommst java.lang.UnsupportedOperationException. In einigen Fällen benötigen Sie sogar Folgendes:

Integer[] values = { 1, 3, 7 };
List<Integer> list = new ArrayList<Integer>(Arrays.asList(values));

Der erste Ansatz konvertiert das Array eigentlich nicht, sondern repräsentiert es wie ein List. Das Array befindet sich jedoch unter der Haube mit all seinen Eigenschaften wie einer festen Anzahl von Elementen. Bitte beachten Sie, dass Sie beim Erstellen einen Typ angeben müssen ArrayList.

Das Problem ist, dass varargs in Java5 eingeführt wurde und leider auch Arrays.asList()mit einer vararg-Version überladen wurde. So Arrays.asList(spam)wird durch den Java5 Compiler als Vararg Parameter int Arrays verstanden.

Dieses Problem wird ausführlicher in Effective Java 2nd Ed., Kapitel 7, Punkt 42 erläutert.

Es scheint etwas spät zu sein, aber hier sind meine zwei Cent. Wir können nicht haben, List<int>wie intes ein primitiver Typ ist, also können wir nur haben List<Integer>.

Java 8 (int Array)

int[] ints = new int[] {1,2,3,4,5};
List<Integer> list11 =Arrays.stream(ints).boxed().collect(Collectors.toList()); 

Java 8 und niedriger (Integer Array)

Integer[] integers = new Integer[] {1,2,3,4,5};
List<Integer> list21 =  Arrays.asList(integers); // returns a fixed-size list backed by the specified array.
List<Integer> list22 = new ArrayList<>(Arrays.asList(integers)); // good
List<Integer> list23 = Arrays.stream(integers).collect(Collectors.toList()); //Java 8 only

Benötigen Sie ArrayList und nicht List?

Wenn wir eine spezifische Implementierung von ListzB ArrayListwollen, können wir verwenden toCollectionals:

ArrayList<Integer> list24 = Arrays.stream(integers)
                          .collect(Collectors.toCollection(ArrayList::new));

Warum list21kann nicht strukturell verändert werden?

Wenn wir Arrays.asListdie Größe der zurückgegebenen Liste verwenden, ist dies fest, da es sich bei der zurückgegebenen Liste nicht um java.util.ArrayListeine private statische Klasse handelt, die darin definiert ist java.util.Arrays. Wenn wir also Elemente zur zurückgegebenen Liste hinzufügen oder daraus entfernen, UnsupportedOperationExceptionwird ein ausgelöst. Wir sollten also weitermachen, list22wenn wir die Liste ändern möchten. Wenn wir Java8 haben, können wir auch mit gehen list23.

Klar zu sein list21kann in dem Sinne geändert werden, dass wir es aufrufen können, list21.set(index,element)aber diese Liste kann möglicherweise nicht strukturell geändert werden, dh es können keine Elemente zur Liste hinzugefügt oder daraus entfernt werden. Sie können diese Frage auch überprüfen .

Wenn wir eine unveränderliche Liste wollen, können wir sie wie folgt umschließen:

List<Integer> list 22 = Collections.unmodifiableList(Arrays.asList(integers));

Ein weiterer zu beachtender Punkt ist, dass die Methode Collections.unmodifiableListeine nicht veränderbare Ansicht der angegebenen Liste zurückgibt. Eine nicht modifizierbare Ansichtssammlung ist eine Sammlung, die nicht modifizierbar ist und auch eine Ansicht auf eine Hintergrundsammlung darstellt. Beachten Sie, dass Änderungen an der Hintergrundsammlung möglicherweise weiterhin möglich sind. Wenn sie auftreten, sind sie in der nicht veränderbaren Ansicht sichtbar.

Wir können eine wirklich unveränderliche Liste in Java 9 und 10 haben.

Wirklich unveränderliche Liste

Java 9:

String[] objects = {"Apple", "Ball", "Cat"};
List<String> objectList = List.of(objects);

Java 10 (wirklich unveränderliche Liste) auf zwei Arten:

1. List.copyOf(Arrays.asList(integers))
2. Arrays.stream(integers).collect(Collectors.toUnmodifiableList());

Überprüfen Sie auch meine Antwort für mehr.

Noch kürzer:

List<Integer> list = Arrays.asList(1, 2, 3, 4);

Ich musste kürzlich ein Array in eine Liste konvertieren. Später hat das Programm die Liste gefiltert, um die Daten zu entfernen. Wenn Sie die Funktion Arrays.asList (Array) verwenden, erstellen Sie eine Sammlung mit fester Größe: Sie können weder hinzufügen noch löschen. Dieser Eintrag erklärt das Problem besser als ich kann: Warum erhalte ich eine UnsupportedOperationException, wenn ich versuche, ein Element aus einer Liste zu entfernen? .

Am Ende musste ich eine "manuelle" Konvertierung durchführen:

    List<ListItem> items = new ArrayList<ListItem>();
    for (ListItem item: itemsArray) {
        items.add(item);
    }

Ich nehme an, ich hätte mithilfe einer List.addAll-Operation (items) eine Konvertierung von einem Array zu einer Liste hinzufügen können.

Arrays verwenden

Dies ist der einfachste Weg, ein Array in zu konvertieren List. Wenn Sie jedoch versuchen, ein neues Element hinzuzufügen oder ein vorhandenes Element aus der Liste zu entfernen, wird ein Element UnsupportedOperationExceptionausgelöst.

Integer[] existingArray = {1, 2, 3};
List<Integer> list1 = Arrays.asList(existingArray);
List<Integer> list2 = Arrays.asList(1, 2, 3);

// WARNING:
list2.add(1);     // Unsupported operation!
list2.remove(1);  // Unsupported operation!

Verwenden von ArrayList- oder anderen Listenimplementierungen

Sie können eine forSchleife verwenden, um alle Elemente des Arrays zu einer ListImplementierung hinzuzufügen , z ArrayList.

List<Integer> list = new ArrayList<>();
for (int i : new int[]{1, 2, 3}) {
  list.add(i);
}

Verwenden der Stream-API in Java 8

Sie können das Array in einen Stream verwandeln und dann den Stream mit verschiedenen Kollektoren sammeln: Der Standardkollektor in Java 8 wird ArrayListhinter dem Bildschirm verwendet, aber Sie können auch Ihre bevorzugte Implementierung festlegen.

List<Integer> list1, list2, list3;
list1 = Stream.of(1, 2, 3).collect(Collectors.toList());
list2 = Stream.of(1, 2, 3).collect(Collectors.toCollection(ArrayList::new));
list3 = Stream.of(1, 2, 3).collect(Collectors.toCollection(LinkedList::new));

Siehe auch:

• Warum verwenden wir Autoboxing und Unboxing in Java?
• Wann wird LinkedList über ArrayList verwendet?

Eine weitere Problemumgehung, wenn Sie Apache commons-lang verwenden:

int[] spam = new int[] { 1, 2, 3 };
Arrays.asList(ArrayUtils.toObject(spam));

Wo ArrayUtils.toObject Konvertiten int[]zuInteger[]

Sie müssen in Array umwandeln

Arrays.asList((Object[]) array)

Einzeiler:

List<Integer> list = Arrays.asList(new Integer[] {1, 2, 3, 4});

In Java 9 haben Sie die noch elegantere Lösung, unveränderliche Listen über die neue Convenience-Factory-Methode zu verwenden List.of:

List<String> immutableList = List.of("one","two","three");

(schamlos von hier kopiert )

Wenn Sie auf Java 8 (oder höher) abzielen, können Sie Folgendes versuchen:

int[] numbers = new int[] {1, 2, 3, 4};
List<Integer> integers = Arrays.stream(numbers)
                        .boxed().collect(Collectors.<Integer>toList());

HINWEIS:

Beachten Collectors.<Integer>toList()Sie, dass diese generische Methode Ihnen hilft, den Fehler "Typinkongruenz: Konvertiert nicht von List<Object>nach List<Integer>" zu vermeiden .

1. Verwenden von Guave:

   Integer[] array = { 1, 2, 3};
   List<Integer> list = Lists.newArrayList(sourceArray);

2. Verwenden von Apache Commons-Sammlungen:

   Integer[] array = { 1, 2, 3};
   List<Integer> list = new ArrayList<>(6);
   CollectionUtils.addAll(list, array);

Wenn dies hilft: Ich hatte das gleiche Problem und habe einfach eine generische Funktion geschrieben, die ein Array verwendet und eine ArrayList desselben Typs mit demselben Inhalt zurückgibt:

public static <T> ArrayList<T> ArrayToArrayList(T[] array) {
    ArrayList<T> list = new ArrayList<T>();
    for(T elmt : array) list.add(elmt);
    return list;
}

Gegebenes Array:

    int[] givenArray = {2,2,3,3,4,5};

Konvertieren eines Integer-Arrays in eine Integer-Liste

Eine Möglichkeit: boxed () -> gibt den IntStream zurück

    List<Integer> givenIntArray1 = Arrays.stream(givenArray)
                                  .boxed()
                                  .collect(Collectors.toList());

Zweiter Weg: Ordnen Sie jedes Element des Streams Integer zu und sammeln Sie es dann

HINWEIS: Mit mapToObj können Sie jedes int-Element in einen String-Stream, einen Char-Stream usw. umwandeln, indem Sie i in (char) i setzen

    List<Integer> givenIntArray2 = Arrays.stream(givenArray)
                                         .mapToObj(i->i)
                                         .collect(Collectors.toList());

Konvertieren eines Array-Typs in einen anderen Typ Beispiel:

List<Character> givenIntArray2 = Arrays.stream(givenArray)
                                             .mapToObj(i->(char)i)
                                             .collect(Collectors.toList());

Es hängt also davon ab, welche Java-Version Sie versuchen.

Java 7

 Arrays.asList(1, 2, 3);

ODER

       final String arr[] = new String[] { "G", "E", "E", "K" };
       final List<String> initialList = new ArrayList<String>() {{
           add("C");
           add("O");
           add("D");
           add("I");
           add("N");
       }};

       // Elements of the array are appended at the end
       Collections.addAll(initialList, arr);

ODER

Integer[] arr = new Integer[] { 1, 2, 3 };
Arrays.asList(arr);

In Java 8

int[] num = new int[] {1, 2, 3};
List<Integer> list = Arrays.stream(num)
                        .boxed().collect(Collectors.<Integer>toList())

Referenz - http://www.codingeek.com/java/how-to-convert-array-to-list-in-java/

Können Sie diese Antwort bitte verbessern, da dies das ist, was ich benutze, aber ich bin nicht 100% klar. Es funktioniert gut, aber IntelliJ hat eine neue WeatherStation hinzugefügt [0]. Warum die 0?

    public WeatherStation[] removeElementAtIndex(WeatherStation[] array, int index)
    {
        List<WeatherStation> list = new ArrayList<WeatherStation>(Arrays.asList(array));
        list.remove(index);
        return list.toArray(new WeatherStation[0]);
    }

Verwenden Sie zwei Codezeilen, um das Array in eine Liste zu konvertieren. Wenn Sie es als ganzzahligen Wert verwenden, müssen Sie den Autoboxing-Typ für den primitiven Datentyp verwenden

  Integer [] arr={1,2};
  Arrays.asList(arr);