Wie int [] in List in Java konvertieren?

Question

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

Natürlich, ich bin in jeder anderen Antwort interessiert, als es in einer Schleife, Punkt für Punkt zu tun. Aber wenn es gibt keine andere Antwort, ich werde wählen, dass ein als die beste, die Tatsache zu zeigen, dass diese Funktionalität ist nicht Teil von Java.

Answer 1

Es gibt keine Abkürzung für von int[] Umwandlung als List<Integer> Arrays.asList nicht mit Boxen befassen und wird nur ein List<int[]> schaffen, das ist nicht das, was Sie wollen. Sie müssen ein Dienstprogramm Methode machen.

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

Answer 2

Streams

In Java 8 Sie können dies tun,

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

Answer 3

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

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

Answer 4

Arrays.asList wird nicht funktionieren, wie einige der anderen Antworten erwarten.

Dieser Code wird nicht eine Liste von 10 Zahlen erstellen. Es druckt 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());

Es wird eine Liste von ganzen Zahlen erstellen:

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

Wenn Sie schon ein Array von ints haben, gibt es nicht schnellen Weg zu konvertieren, du bist besser dran mit der Schleife.

Auf der anderen Seite, wenn Ihr Array Objekte hat, nicht Primitiven darin, Arrays.asList funktioniert:

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

Answer 5

Ich werde eine andere Antwort mit einer anderen Methode hinzufügen; keine Schleife, sondern eine anonyme Klasse, die die Autoboxing Features werden nutzen:

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

Answer 6

Das kleinste Stück Code wäre:

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

wo ArrayUtils kommt von commons-lang:)

Answer 7

In Java 8 mit Strom:

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

oder mit Collectors

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

Answer 8

In Java 8:

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

Answer 9

Es ist auch ein Besuch wert diesen Bug-Reports , die geschlossen wurde mit Grunde „nicht um einen Defekt“ und den folgenden Text:

"Autoboxing ganzer Arrays nicht Verhalten angegeben, aus gutem Grund. Es kann für großen Arrays unerschwinglich teuer sein. "

Answer 10

gibt einen Versuch zu dieser Klasse:

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

Answer 11

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 erhalten und eingestellt werden.
• Keine Speicher Datenduplizierung.
• Keine Zeit zu verschwenden in Schleifen.

Beispiele:

int[] intArray = new int[]{1, 2, 3};
List<Integer> integerListWrap = new IntegerListWrap(intArray);
List<Integer> integerListWrap1 = new IntegerListWrap(1, 2, 3);

Answer 12

Wenn Sie mit Java-8, können wir den Stream-API verwenden, es in eine Liste zu konvertieren.

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

Sie können auch die IntStream als auch verwenden, zu konvertieren.

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

Es gibt noch andere externe Bibliothek wie Guave und Apache Commons  auch sie konvertieren.

prost.

Answer 13

Wenn Sie eine Drittanbieter-Bibliothek zur Verwendung offen sind, wird diese Arbeit 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

Answer 14

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

Answer 15

Was folgt aus:

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

Answer 16

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]

Answer 17

Hier ist eine weitere 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]));
}

Answer 18

Hier ist eine generische Art und Weise Array Arraylist zu konvertieren

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

Verwendung

ArrayList<Integer> list = toArrayList(new int[]{1,2,3}, Integer.class);

Answer 19

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