Konvertieren von Array-Liste in Java

Question

Wie konvertiere ich ein Array in eine Liste in Java?

habe ich das Arrays.asList() aber das Verhalten (und Unterschrift) irgendwie von Java SE 1.4.2 (docs jetzt im Archiv) auf 8 und die meisten Schnipsel ich die 1.4.2 Verhalten im Web Verwendung gefunden.

Zum Beispiel:

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

• 1.4.2 auf kehrt eine Liste mit den Elementen 1, 2, 3
• auf 1.5.0+ kehrt eine Liste mit dem Array-Spam

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

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

Answer 1

In Ihrem Beispiel, ist es, weil Sie nicht eine Liste von einem primitiven Typ haben können. Mit anderen Worten, ist List<int> nicht möglich.

Sie können, haben jedoch eine List<Integer> die Integer Klasse, die die int primitive wickelt. Konvertieren Sie Ihre Array ein List mit der Arrays.asList Hilfsmethode.

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

Sehen Sie diesen Code ausführen bei IdeOne.com .

Answer 2

In Java 8 können Sie Streams verwenden:

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

Answer 3

Sprechen über Umwandlung Art und Weise, es hängt davon ab, warum brauchen Sie Ihre List. Wenn Sie es brauchen nur Daten zu lesen. OK, hier gehen Sie:

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

Aber dann, wenn Sie etwas tun, wie folgt aus:

list.add(1);

Sie erhalten java.lang.UnsupportedOperationException. Also für einige Fälle müssen Sie auch diese:

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

Erster Ansatz konvertiert eigentlich nicht Array sondern ‚für‘ es wie ein List. Aber Array ist unter der Haube mit allen seinen Eigenschaften wie feste Anzahl von Elementen. Bitte beachten Sie müssen Typen angeben, wenn ArrayList zu konstruieren.

Answer 4

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

Dieses Problem wird in mehr Details in Effective Java 2nd Ed erklärt., Kapitel 7, Artikel 42.

Answer 5

Es scheint wenig spät, aber hier meine zwei Cent sind. Wir können nicht List<int> als int ein primitiver Typ ist, so dass 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 unten (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

Need Arraylist und nicht die Liste?

Im Fall, dass wir eine spezielle Implementierung von List z.B. ArrayList dann können wir verwenden toCollection wie:

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

---

Warum list21 kann nicht strukturell verändert werden?

Wenn wir verwenden Arrays.asList die Größe der zurückgegebenen Liste festgelegt ist, weil die Liste nicht zurückgegeben java.util.ArrayList ist, sondern eine private statische Klasse in java.util.Arrays definiert. Also, wenn wir Elemente aus der zurückgegebenen Liste hinzuzufügen oder zu entfernen, wird ein UnsupportedOperationException geworfen werden. Also sollten wir mit list22 gehen, wenn wir die Liste ändern möchten. Wenn wir Java8 haben, dann können wir auch mit list23 gehen.

klar list21 Um in Sinne geändert werden, dass wir list21.set(index,element) nennen können, aber diese Liste nicht strukturell modifiziert werden kann, das heißt nicht hinzufügen oder entfernen Elemente aus der Liste. Sie können auch überprüfen Sie diese Frage .

---

Wenn wir eine unveränderliche Liste wollen, dann können wir es wickeln wie:

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

Ein weiterer Punkt zu beachten ist, dass das Verfahren Collections.unmodifiableList eine unveränderbare Ansicht der angegebenen Liste zurückgibt. Eine unmodifiable Ansicht Sammlung ist eine Sammlung, die als nicht änderbar ist, und ist auch eine Ansicht auf einen Träger Sammlung. Beachten Sie, dass an den Träger Sammlung ändert vielleicht noch möglich sein, und wenn sie auftreten, sind sie sichtbar durch die unveränderbare Ansicht.

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

Java 10 (Wirklich Immutable Liste) auf zwei Arten:

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

Überprüfen Sie auch diese Antwort von mir für mehr.

Answer 6

ich ein Array zu konvertieren, um eine Liste vor kurzem hatte. Später auf dem Programm gefiltert, um die Liste zu versuchen, die Daten zu löschen. Wenn Sie die Arrays.asList (Array) Funktion zu verwenden, erstellen Sie eine feste Größe Sammlung: Sie können weder hinzufügen noch löschen. Dieser Eintrag erklärt das Problem besser als ich kann: Warum muß ich ein UnsupportedOperationException erhalten, wenn ein Element aus einer Liste? zu entfernen versuchen.

Am Ende hatte ich eine „Handbuch“ Umwandlung zu tun:

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

Ich glaube, ich Umwandlung von einer Anordnung zu einer Liste hinzugefügt habe, könnte einen List.addAll (Artikel) Betrieb mit.

Answer 7

Noch kürzere:

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

Answer 8

Verwenden von Arrays

Dies ist der einfachste Weg, um ein Array zu List zu konvertieren. Allerdings, wenn Sie versuchen, ein neues Element hinzuzufügen oder ein vorhandenes Element aus der Liste zu entfernen, wird ein UnsupportedOperationException geworfen werden.

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!

Mit Arraylist oder andere Liste Implementations

Sie können eine for Schleife verwenden, um alle Elemente des Arrays in eine List Implementierung hinzufügen, zum Beispiel ArrayList:

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

Mit Stream-API in Java 8

Sie können das Array in einen Strom einschalten, sammeln dann den Strom unter Verwendung verschiedene Kollektoren. Der Standard-Kollektor in Java 8 Verwendung ArrayList hinter dem Bildschirm, aber Sie können auch Ihre bevorzugte Implementierung verhängen

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
• Wenn LinkedList über Arraylist verwenden?

Answer 9

Eine andere Lösung, wenn Sie verwenden Apache commons-lang:

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

Wo ArrayUtils.toObject Konvertiten int[] zu Integer[]

Answer 10

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

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

(schamlos kopiert von hier )

Answer 11

Wenn Sie Java zielen 8 (oder höher), können Sie dies 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: kann nicht von List<Object> zu List<Integer> konvertieren“ zu vermeiden.

Answer 12

Sie gegossen haben, um Array

Arrays.asList((Object[]) array)

Answer 13

Einzeiler:

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

Answer 14

1. Mit Guava:

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

2. Mit Apache Commons Kollektionen:

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

Answer 15

Es hängt also von dem Java-Version, die 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/

Answer 16

Wenn das hilft: Ich habe das gleiche Problem habe und schrieb einfach eine generische Funktion, die ein Array nimmt und gibt eine Arraylist des gleichen Typs mit dem gleichen Inhalt:

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

Answer 17

Bei Array:

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

Konvertieren von Integer-Array zu Integer-Liste

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

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

Zweiter Weg: Karte jedes Element des Stroms zu Integer und dann collect

Hinweis: Mit mapToObj können Sie jedes int Element in String-Stream verdeckte, char Strom etc durch Gehäuse i (char) i

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

Konvertieren Eines Array-Typs in einem anderen Typ Beispiel:

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

Answer 18

verwenden, um zwei Codezeilen zu konvertieren Array-Liste, wenn Sie es in Integer-Wert verwenden Sie müssen Autoboxing Typen für primitiven Datentyp

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