web-dev-qa-db-de.com

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

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

Natürlich interessiert mich jede andere Antwort, als dass ich es in einer Schleife mache, Stück für Stück. Wenn es keine andere Antwort gibt, wähle ich diese am besten aus, um zu zeigen, dass diese Funktionalität nicht in Java enthalten ist.

290
pupeno

Es gibt keine Abkürzung für die Konvertierung von int[] in List<Integer>, da Arrays.asList sich nicht mit Boxen befasst und lediglich einen List<int[]> erstellt, der nicht Ihren Vorstellungen entspricht. Sie müssen eine Utility-Methode erstellen.

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

Streams

In Java 8 können Sie dies tun

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

Auch aus guava-Bibliotheken ... com.google.common.primitives.Ints:

List<Integer> Ints.asList(int...)
162
louisgab

Arrays.asList funktioniert nicht wie von den anderen Antworten erwartet.

Dieser Code erstellt not eine Liste mit 10 Ganzzahlen. Es wird gedruckt 1 , 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 mit Ganzzahlen erstellt:

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

Wenn Sie bereits über ein Array von Ints verfügen, gibt es keine schnelle Konvertierungsmethode. Sie sind besser in der Schleife.

Wenn Ihr Array dagegen Objekte und keine Primitiven enthält, funktioniert Arrays.asList:

String str[] = { "Homer", "Marge", "Bart", "Lisa", "Maggie" };
List<String> lst = Arrays.asList(str);
76
Leonel

Ich füge eine andere Antwort mit einer anderen Methode hinzu. Keine Schleife, sondern eine anonyme Klasse, die die Autoboxing-Funktionen verwendet:

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

Das kleinste Stück Code wäre:

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

wo ArrayUtils von commons-lang kommt :)

35
Kannan Ekanath

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 Sammler

List<Integer> list =  Arrays.stream(ints).boxed().collect(Collectors.toList());
20
user2037659

In Java 8: 

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

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

"Autoboxing von ganzen Arrays ist aus gutem Grund kein genaues Verhalten.

10
Adamski

gib dieser Klasse einen Versuch:

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
8
dfa

Die beste Einstellung:

**
 * 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 erhalten und einstellen.
  • Keine Speicherdaten-Duplizierung.
  • Keine Verschwendung von Zeit in Schleifen.

Beispiele:

int[] intArray = new int[]{1, 2, 3};
List<Integer> integerListWrap = new IntegerListWrap(intArray);
List<Integer> integerListWrap1 = new IntegerListWrap(1, 2, 3);
5
Daniel De León

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 andere externe Bibliotheken wie Guava und Apache Commons, die ebenfalls verfügbar sind.

prost.

3

Was ist mit diesem:

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

1
humblefoolish

Hier ist eine weitere Möglichkeit, wiederum mit Java 8 Streams:

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

Wenn Sie die Bibliothek eines Drittanbieters verwenden möchten, funktioniert dies in Eclipse Collections :

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 Committer für Eclipse Collections .

1
Donald Raab

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]
1
Amitabha Roy
   /* 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);
1
Uddhav Gautam

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);
0
Ilya Gazman

Ich frage mich, ob etwas in der Richtung von Arrays.asList(...array) funktionieren würde ...

0
Solomon Ucko