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

Streams

In Java 8 können Sie dies tun

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

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

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

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

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

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

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

In Java 8: 

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

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.

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

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

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.

Was ist mit diesem:

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

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

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 .

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]

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

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

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