Wie konvertiere ich int [] in List <Integer> in Java?

382

Wie konvertiere ich int[]inList<Integer> in Java?

Natürlich interessiert mich jede andere Antwort, als sie Punkt für Punkt in einer Schleife zu machen. Wenn es jedoch keine andere Antwort gibt, werde ich diese als die beste auswählen, um zu zeigen, dass diese Funktionalität nicht Teil von Java ist.

pupeno
quelle
Wir können IntStream.Of (Array) .collect (Collectors.toList)
Saroj Kumar Sahoo

Antworten:

259

Es gibt keine Abkürzung für die Konvertierung von int[]nach, List<Integer>da Arrays.asListes sich nicht um Boxen handelt und nur eine erstellt wird, List<int[]>die nicht Ihren Wünschen entspricht. Sie müssen eine Dienstprogrammmethode erstellen.

int[] ints = {1, 2, 3};
List<Integer> intList = new ArrayList<Integer>(ints.length);
for (int i : ints)
{
    intList.add(i);
}
willcodejavaforfood
quelle
32
Es ist am besten, die Liste mit der Größe des Arrays zu initialisieren
David Rabinowitz
110
für (int i: ints) intList.add (i);
Stephen Denne
18
@willcodejavaforfood - David bedeutet, dass dies besser ist: new ArrayList <Integer> (ints.length);
Stephen Denne
12
@willcodejavaforfood: Wenn Sie die Größe der ArrayList beim Erstellen angeben, muss die Größe nach dem Hinzufügen einer bestimmten Menge nicht intern geändert werden. Ich bin mir nicht sicher, ob der Nutzen gering ist, aber es gibt definitiv einen Vorteil.
Grundlefleck
10
new ArrayList<Integer>() {{ for (int i : ints) add(i); }}
saka1029
350

Streams

In Java 8 können Sie dies tun

int[] ints = {1,2,3};
List<Integer> list = Arrays.stream(ints).boxed().collect(Collectors.toList());
mikeyreilly
quelle
21
Entspricht: Arrays.stream (ints) .boxed (). Collect (Collectors.toList ());
NJFrost
4
@njfrost Sie haben Recht und IntStream.of ruft nur Arrays.stream an, also habe ich die Antwort nach Ihrem Vorschlag verbessert
mikeyreilly
Aus irgendeinem Grund scheint dies nicht den erwarteten Ergebnistyp unter Android Studio zurückzugeben (funktioniert bei Eclipse). Es heißt, erwartete Liste <Integer> gefundene Liste <Objekt>.
Eugenio Lopez
Es sieht sauber und prägnant aus, aber als ich dies im Gegensatz zu der von @willcodejavaforfood für Leetcode bereitgestellten Basislösung verwendete, verschlechterte sich die Programmleistung sowohl hinsichtlich des Speichers als auch der Laufzeit
chitresh sirohi
@chitreshsirohi, weil Lambda-Funktionen, die in Streams verwendet werden, dazu führen, dass Java einige anonyme Klassen erstellt.
Ashvin Sharma
175

Auch aus Guave Bibliotheken ... com.google.common.primitives.Ints:

List<Integer> Ints.asList(int...)
Louisgab
quelle
11
Dieser sollte die richtige Antwort sein. Siehe den zweiten Satz der Frage: "Natürlich interessiert mich jede andere Antwort als die in einer Schleife, Punkt für Punkt."
Josketres
Danke danke danke! Funktioniert auch für Longs.asList (long ...).
Craastad
2
Hier gibt es einige Feinheiten. Die zurückgegebene Liste verwendet das bereitgestellte Array als Sicherungsspeicher, daher sollten Sie das Array nicht mutieren. Die Liste garantiert auch nicht die Identität der enthaltenen Integer-Objekte. Das heißt, das Ergebnis von list.get (0) == list.get (0) ist nicht angegeben.
pburka
1
Achten Sie beim Hinzufügen von Bibliotheken auf die Anzahl der Methodenreferenzen unter Android. Guter Fund.
Milosmns
95

Arrays.asList funktioniert nicht wie einige der anderen Antworten erwarten.

Dieser Code erstellt keine Liste mit 10 Ganzzahlen. Es wird 1 gedruckt , nicht 10 :

int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
List lst = Arrays.asList(arr);
System.out.println(lst.size());

Dadurch wird eine Liste von Ganzzahlen erstellt:

List<Integer> lst = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

Wenn Sie bereits über ein Ints-Array verfügen, gibt es keine schnelle Möglichkeit zum Konvertieren. Mit der Schleife sind Sie besser dran.

Wenn Ihr Array jedoch Objekte und keine Grundelemente enthält, funktioniert Arrays.asList wie folgt:

String str[] = { "Homer", "Marge", "Bart", "Lisa", "Maggie" };
List<String> lst = Arrays.asList(str);
Leonel
quelle
2
Beachten Sie, dass diese Liste unveränderlich ist
Danielson
51

Ich werde eine andere Antwort mit einer anderen Methode hinzufügen; Keine Schleife, sondern eine anonyme Klasse, die die Autoboxing-Funktionen nutzt:

public List<Integer> asList(final int[] is)
{
    return new AbstractList<Integer>() {
            public Integer get(int i) { return is[i]; }
            public int size() { return is.length; }
    };
}
Christoffer
quelle
1
+1 das ist kürzer als meins, aber meins funktioniert für alle primitiven Typen
dfa
5
Obwohl dies schneller ist und weniger Speicher benötigt als das Erstellen einer ArrayList, funktioniert List.add () und List.remove () nicht.
Stephen Denne
3
Ich mag diese Lösung für große Arrays mit spärlichen Zugriffsmustern sehr, aber für Elemente, auf die häufig zugegriffen wird, würde dies zu vielen unnötigen Instanziierungen von Integer führen (z. B. wenn Sie 100 Mal auf dasselbe Element zugegriffen haben). Außerdem müssten Sie Iterator definieren und den Rückgabewert in Collections.unmodizableList einschließen.
Adamski
@Christoffer danke. Ich habe die setMethode hinzugefügt und jetzt kann ich sogar das Array sortieren ...
freedev
39

Der kleinste Code wäre:

public List<Integer> myWork(int[] array) {
    return Arrays.asList(ArrayUtils.toObject(array));
}

wo ArrayUtils von commons-lang kommt :)

Kannan Ekanath
quelle
9
Beachten ArrayUtilsSie nur, dass es sich um eine relativ große Bibliothek für eine Android-App handelt
msysmilu
Der umgekehrte Vorgang wird hier beschrieben: stackoverflow.com/a/960507/1333157 ArrayUtils.toPrimitive(...) ist der Schlüssel.
ZeroOne
26

In Java 8 mit Stream:

int[] ints = {1, 2, 3};
List<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, Arrays.stream(ints).boxed().toArray(Integer[]::new));

oder mit Sammlern

List<Integer> list =  Arrays.stream(ints).boxed().collect(Collectors.toList());
user2037659
quelle
3
Warum nicht einfach einen Sammler benutzen?
Assylias
19

In Java 8:

int[] arr = {1,2,3};
IntStream.of(arr).boxed().collect(Collectors.toList());
Neeraj
quelle
16

Wenn Sie Java 8 verwenden, können wir die Stream-API verwenden, um sie in eine Liste zu konvertieren.

List<Integer> list = Arrays.stream(arr)     // IntStream 
                                .boxed()        // Stream<Integer>
                                .collect(Collectors.toList());

Sie können den IntStream auch zum Konvertieren verwenden.

List<Integer> list = IntStream.of(arr) // return Intstream
                                    .boxed()        // Stream<Integer>
                                    .collect(Collectors.toList());

Es gibt auch andere externe Bibliotheken wie Guava und Apache Commons, die ebenfalls konvertiert werden können.

Prost.

Mukesh Kumar Gupta
quelle
11

Es lohnt sich auch, diesen Fehlerbericht zu lesen , der mit dem Grund "Kein Fehler" und dem folgenden Text geschlossen wurde:

"Autoboxing ganzer Arrays ist aus gutem Grund kein spezifiziertes Verhalten. Es kann für große Arrays unerschwinglich teuer sein."

Adamski
quelle
7

Probieren Sie diese Klasse aus:

class PrimitiveWrapper<T> extends AbstractList<T> {

    private final T[] data;

    private PrimitiveWrapper(T[] data) {
        this.data = data; // you can clone this array for preventing aliasing
    }

    public static <T> List<T> ofIntegers(int... data) {
        return new PrimitiveWrapper(toBoxedArray(Integer.class, data));
    }

    public static <T> List<T> ofCharacters(char... data) {
        return new PrimitiveWrapper(toBoxedArray(Character.class, data));
    }

    public static <T> List<T> ofDoubles(double... data) {
        return new PrimitiveWrapper(toBoxedArray(Double.class, data));
    }  

    // ditto for byte, float, boolean, long

    private static <T> T[] toBoxedArray(Class<T> boxClass, Object components) {
        final int length = Array.getLength(components);
        Object res = Array.newInstance(boxClass, length);

        for (int i = 0; i < length; i++) {
            Array.set(res, i, Array.get(components, i));
        }

        return (T[]) res;
    }

    @Override
    public T get(int index) {
        return data[index];
    }

    @Override
    public int size() {
        return data.length;
    }
}

Testfall:

List<Integer> ints = PrimitiveWrapper.ofIntegers(10, 20);
List<Double> doubles = PrimitiveWrapper.ofDoubles(10, 20);
// etc
dfa
quelle
5

Der beste Schuss:

**
 * Integer modifiable fix length list of an int array or many int's.
 *
 * @author Daniel De Leon.
 */
public class IntegerListWrap extends AbstractList<Integer> {

    int[] data;

    public IntegerListWrap(int... data) {
        this.data = data;
    }

    @Override
    public Integer get(int index) {
        return data[index];
    }

    @Override
    public Integer set(int index, Integer element) {
        int r = data[index];
        data[index] = element;
        return r;
    }

    @Override
    public int size() {
        return data.length;
    }
}
  • Unterstützung bekommen und einstellen.
  • Keine Speicherdatenverdoppelung.
  • Keine Zeitverschwendung in Schleifen.

Beispiele:

int[] intArray = new int[]{1, 2, 3};
List<Integer> integerListWrap = new IntegerListWrap(intArray);
List<Integer> integerListWrap1 = new IntegerListWrap(1, 2, 3);
Daniel De León
quelle
Ich mag es am meisten. Aber ich würde immer noch Guave verwenden, um eine einfache Lösung zu haben :)
Dantuch
1

Wenn Sie offen sind, eine Bibliothek eines Drittanbieters zu verwenden, funktioniert dies in Eclipse-Sammlungen :

int[] a = {1, 2, 3};
List<Integer> integers = IntLists.mutable.with(a).collect(i -> i);
Assert.assertEquals(Lists.mutable.with(1, 2, 3), integers);

Hinweis: Ich bin ein Committer für Eclipse-Sammlungen .

Donald Raab
quelle
1
   /* Integer[] to List<Integer> */



        Integer[] intArr = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
        List<Integer> arrList = new ArrayList<>();
        arrList.addAll(Arrays.asList(intArr));
        System.out.println(arrList);


/* Integer[] to Collection<Integer> */


    Integer[] intArr = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
    Collection<Integer> c = Arrays.asList(intArr);
Uddhav Gautam
quelle
1

Was ist damit:

int[] a = {1,2,3}; Integer[] b = ArrayUtils.toObject(a); List<Integer> c = Arrays.asList(b);

bescheiden dumm
quelle
1

Hier ist eine Lösung:

int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

Integer[] iArray = Arrays.stream(array).boxed().toArray(Integer[]::new);
System.out.println(Arrays.toString(iArray));

List<Integer> list = new ArrayList<>();
Collections.addAll(list, iArray);
System.out.println(list);

Ausgabe:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Amitabha Roy
quelle
1

Hier ist eine andere Möglichkeit, wieder mit Java 8 Streams:

void intArrayToListOfIntegers(int[] arr, List<Integer> list) {
    IntStream.range(0, arr.length).forEach(i -> list.add(arr[i]));
}
Koray Tugay
quelle
0

Hier ist eine generische Methode zum Konvertieren von Arrays in ArrayList

<T> ArrayList<T> toArrayList(Object o, Class<T> type){
    ArrayList<T> objects = new ArrayList<>();
    for (int i = 0; i < Array.getLength(o); i++) {
        //noinspection unchecked
        objects.add((T) Array.get(o, i));
    }
    return objects;
}

Verwendungszweck

ArrayList<Integer> list = toArrayList(new int[]{1,2,3}, Integer.class);
Ilya Gazman
quelle
0
int[] arr = { 1, 2, 3, 4, 5 };

List<Integer> list = Arrays.stream(arr)     // IntStream
                            .boxed()        // Stream<Integer>
                            .collect(Collectors.toList());

sieh das

hamidreza75
quelle