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.

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

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 Guave Bibliotheken ... com.google.common.primitives.Ints:

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

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

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

Der kleinste 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 Sammlern

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

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.

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."

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

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

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 .

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

Was ist damit:

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

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]

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

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

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

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

sieh das