it-swarm.com.de

Array in Liste in Java konvertieren

Wie konvertiere ich ein Array in eine Liste in Java?

Ich habe Arrays.asList() verwendet, aber das Verhalten (und die Signatur) haben sich irgendwie von Java SE 1.4.2 (docs now in archive) zu 8 geändert = und die meisten Schnipsel, die ich im Web gefunden habe, verwenden das 1.4.2-Verhalten.

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

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

Sie können jedoch einen _List<Integer>_ mit der Klasse Integer haben, die das Grundelement int umschließt. Konvertieren Sie Ihr Array mit der Utility-Methode Arrays.asList in ein List .

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

Siehe dies Code wird live auf IdeOne.com ausgeführt .

1316
Joe Daley

In Java 8 können Sie Streams verwenden:

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

Was die Art der Konvertierung betrifft, hängt es davon ab, warum Sie Ihr List benötigen. 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 erhältst 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 nicht, sondern 'repräsentiert' es wie ein List. Aber Array ist unter der Haube mit all seinen Eigenschaften wie feste Anzahl von Elementen. Bitte beachten Sie, dass Sie bei der Erstellung von ArrayList den Typ angeben müssen.

127

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

Weitere Informationen zu diesem Problem finden Sie in Effective Java 2nd Ed., Kapitel 7, Punkt 42.

118
Péter Török

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

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 darunter (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?

Falls wir eine spezifische Implementierung von List wünschen, z. ArrayList dann können wir toCollection verwenden als:

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

Warum kann list21 nicht strukturell geändert werden?

Wenn wir Arrays.asList verwenden, ist die Größe der zurückgegebenen Liste festgelegt, da die zurückgegebene Liste nicht Java.util.ArrayList ist, sondern eine private statische Klasse, die in Java.util.Arrays definiert ist. Wenn wir also Elemente zur zurückgegebenen Liste hinzufügen oder daraus entfernen, wird ein UnsupportedOperationException ausgelöst. Also sollten wir mit list22 gehen, wenn wir die Liste ändern wollen. Wenn wir Java8 haben, können wir auch mit list23 gehen.

Um klar zu sein, kann list21 in dem Sinne geändert werden, dass wir list21.set(index,element) aufrufen können, aber diese Liste kann möglicherweise nicht strukturell geändert werden, d. H. Elemente können der Liste nicht hinzugefügt oder daraus entfernt werden. Sie können dies auch überprüfen Frage .


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

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

Ein weiterer zu beachtender Punkt ist, dass die Methode Collections.unmodifiableList eine nicht ä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 noch möglich sind und in der nicht änderbaren Ansicht angezeigt werden, wenn sie auftreten.

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

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 dieses Antwort von mir für mehr.

87
i_am_zero

Ich musste kürzlich ein Array in eine Liste konvertieren. Später hat das Programm die Liste gefiltert und versucht, die Daten zu entfernen. Wenn Sie die Funktion Arrays.asList (Array) verwenden, erstellen Sie eine Sammlung mit fester Größe: Sie können sie 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 (items) -Operation eine Konvertierung von einem Array zu einer Liste hinzufügen können.

8
Steve Gelman

Noch kürzer:

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

Arrays verwenden

Dies ist die einfachste Möglichkeit, ein Array in List zu konvertieren. Wenn Sie jedoch versuchen, ein neues Element hinzuzufügen oder ein vorhandenes Element aus der Liste zu entfernen, wird ein UnsupportedOperationException ausgelö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 List-Implementierungen

Sie können eine for -Schleife verwenden, um alle Elemente des Arrays zu einer List -Implementierung 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 Collectors sammeln: Der Standard-Collector in Java 8 verwendet ArrayList hinter dem Bildschirm, Sie können jedoch 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:

5
Mincong Huang

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

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

(schamlos kopiert von hier )

3

Wenn Sie Java 8 (oder höher) als Ziel festlegen, 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:

Achten Sie auf die Collectors.<Integer>toList(), diese generische Methode hilft Ihnen, den Fehler "Typenkonflikt: Konvertierung von List<Object> nach List<Integer> nicht möglich" zu vermeiden.

3
nybon

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

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

Wobei ArrayUtils.toObjectint[] in Integer[] konvertiert

3
alaster
  1. Verwendung von Guava:

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

Einzeiler:

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

sie müssen in Array gießen

Arrays.asList((Object[]) array)
2

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

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

Java 7

 Arrays.asList(1, 2, 3);

OR

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

OR

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 /

0
Hitesh Garg