Bagaimana cara saya konversikan int[]ke List<Integer>dalam Java?

Tentu saja, saya tertarik pada jawaban lain selain melakukannya dalam satu lingkaran, item demi item. Tetapi jika tidak ada jawaban lain, saya akan memilih yang terbaik untuk menunjukkan fakta bahwa fungsi ini bukan bagian dari Jawa.

Tidak ada jalan pintas untuk mengkonversi dari int[]ke List<Integer>karena Arrays.asListtidak berurusan dengan tinju dan hanya akan membuat List<int[]>yang bukan yang Anda inginkan. Anda harus membuat metode utilitas.

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

Streaming

Di Java 8 Anda bisa melakukan ini

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

Juga dari perpustakaan jambu biji ... com.google.common.primitive.Ints:

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

Arrays.asList tidak akan berfungsi seperti yang diharapkan oleh beberapa jawaban lainnya.

Kode ini tidak akan membuat daftar 10 bilangan bulat. Ini akan mencetak 1 , bukan 10 :

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

Ini akan membuat daftar bilangan bulat:

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

Jika Anda sudah memiliki array int, tidak ada cara cepat untuk mengkonversi, Anda lebih baik dengan loop.

Di sisi lain, jika array Anda memiliki Object, bukan primitif di dalamnya, Arrays.asList akan berfungsi:

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

Saya akan menambahkan jawaban lain dengan metode yang berbeda; tidak ada loop tetapi kelas anonim yang akan memanfaatkan fitur autoboxing:

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

Sepotong kode terkecil adalah:

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

dari mana ArrayUtils berasal dari commons-lang :)

Di Java 8 dengan streaming:

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

atau dengan Kolektor

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

Di Jawa 8:

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

Jika Anda menggunakan java 8, kita dapat menggunakan API aliran untuk mengubahnya menjadi daftar.

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

Anda juga dapat menggunakan IntStream untuk mengonversi juga.

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

Ada perpustakaan eksternal lain seperti jambu biji dan apache commons juga tersedia untuk mengubahnya.

Bersulang.

Juga patut untuk memeriksa laporan bug ini , yang ditutup dengan alasan "Bukan cacat" dan teks berikut:

"Autoboxing seluruh array bukanlah perilaku yang ditentukan, untuk alasan yang baik. Ini bisa mahal untuk array besar."

coba kelas ini:

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

Kasus cobaan:

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

Tembakan terbaik:

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

• Dukungan dapatkan dan atur.
• Tidak ada duplikasi data memori.
• Tidak membuang waktu dalam loop.

Contoh:

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

Jika Anda terbuka untuk menggunakan perpustakaan pihak ketiga, ini akan berfungsi di 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);

Catatan: Saya pengendara untuk Eclipse Collections .

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

Bagaimana dengan ini:

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

Ini solusinya:

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

Keluaran:

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

Berikut adalah kemungkinan lain, lagi dengan Java 8 Streams:

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

Berikut ini adalah cara umum untuk mengkonversi array ke 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;
}

Pemakaian

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

lihat ini