Bagaimana cara mengubah int [] ke Daftar <Integer> di Jawa?

382

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.

pupeno
sumber
Kita dapat menggunakan IntStream.Of (array) .collect (Collectors.toList)
Saroj Kumar Sahoo

Jawaban:

259

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);
}
willcodejavaforfood
sumber
32
Cara terbaik untuk menginisialisasi daftar dengan ukuran array
David Rabinowitz
110
untuk (int i: ints) intList.add (i);
Stephen Denne
18
@willcodejavaforfood - David berarti ini lebih baik: ArrayList baru <Integer> (ints.length);
Stephen Denne
12
@willcodejavaforfood: menyatakan ukuran ArrayList ketika sedang dibangun akan mencegahnya harus mengubah ukuran secara internal setelah jumlah tertentu ditambahkan. Tidak yakin apakah manfaatnya kecil, tetapi pasti ada manfaatnya.
Grundlefleck
10
new ArrayList<Integer>() {{ for (int i : ints) add(i); }}
saka1029
350

Streaming

Di Java 8 Anda bisa melakukan ini

int[] ints = {1,2,3};
List<Integer> list = Arrays.stream(ints).boxed().collect(Collectors.toList());
mikeyreilly
sumber
21
Setara dengan: Arrays.stream (ints) .boxed (). Collect (Collectors.toList ());
njfrost
4
@ njfrost Anda benar dan IntStream.sebaiknya panggil Arrays.stream jadi saya telah memperbaiki jawaban mengikuti saran Anda
mikeyreilly
Untuk beberapa alasan ini sepertinya tidak mengembalikan tipe hasil yang diharapkan pada Android Studio (berfungsi pada gerhana) Dikatakan, diharapkan Daftar <Integer> ditemukan Daftar <Object>.
Eugenio Lopez
Ini terlihat bersih dan ringkas tetapi ketika saya menggunakan ini sebagai lawan dari solusi dasar yang disediakan oleh @willcodejavaforfood pada leetcode kinerja program menurun dalam hal memori serta runtime
chitresh sirohi
@ chitreshsirohi karena fungsi lambda yang digunakan di dalam stream menghasilkan Java untuk membuat beberapa kelas anonim.
Ashvin Sharma
175

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

List<Integer> Ints.asList(int...)
louisgab
sumber
11
Yang ini harus menjadi jawaban yang tepat. Lihat kalimat kedua dari pertanyaan: "Tentu saja, saya tertarik pada jawaban lain selain melakukannya dalam satu lingkaran, item demi item."
josketres
Terima kasih terima kasih terima kasih! Juga berfungsi untuk Longs.asList (long ...).
craastad
2
Ada beberapa kehalusan di sini. Daftar yang dikembalikan menggunakan array yang disediakan sebagai backing store, jadi Anda tidak boleh bermutasi array. Daftar ini juga tidak menjamin identitas objek Integer yang terkandung. Artinya, hasil dari list.get (0) == list.get (0) tidak ditentukan.
pburka
1
Waspadalah terhadap jumlah referensi metode pada Android saat menambahkan perpustakaan. Bagus temukan.
milosmns
95

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);
Leonel
sumber
2
Perhatikan, bahwa daftar itu tidak dapat diubah
Danielson
51

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; }
    };
}
Christoffer
sumber
1
+1 ini lebih pendek dari milikku tapi milikku bekerja untuk semua tipe primitif
dfa.
5
Meskipun lebih cepat dan menggunakan lebih sedikit memori daripada membuat ArrayList, trade off-nya adalah List.add () dan List.remove () tidak berfungsi.
Stephen Denne
3
Saya sangat menyukai solusi ini untuk array besar dengan pola akses yang jarang tetapi untuk elemen yang sering diakses akan menghasilkan banyak instantiations Integer yang tidak perlu (misalnya jika Anda mengakses elemen yang sama 100 kali). Anda juga perlu mendefinisikan Iterator dan membungkus nilai kembali di Collections.unmodifiableList.
Adamski
@Christoffer terima kasih. Saya telah menambahkan setmetode dan sekarang saya bahkan dapat mengurutkan array ...
freedev
39

Sepotong kode terkecil adalah:

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

dari mana ArrayUtils berasal dari commons-lang :)

Kannan Ekanath
sumber
9
Perhatikan saja ArrayUtilsbahwa ini adalah perpustakaan yang relatif besar untuk aplikasi Android
msysmilu
Operasi sebaliknya dijelaskan di sini: stackoverflow.com/a/960507/1333157 ArrayUtils.toPrimitive(...) adalah kuncinya.
ZeroOne
26

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());
pengguna2037659
sumber
3
Mengapa tidak menggunakan kolektor saja?
assylias
19

Di Jawa 8:

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

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.

Mukesh Kumar Gupta
sumber
11

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

Adamski
sumber
7

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
dfa
sumber
5

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);
Daniel De León
sumber
Saya paling menyukainya. Tapi saya masih menggunakan jambu biji untuk mendapatkan solusi yang langsung :)
dantuch
1

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 .

Donald Raab
sumber
1
   /* 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);
Uddhav Gautam
sumber
1

Bagaimana dengan ini:

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

humblefoolish
sumber
1

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]
Amitabha Roy
sumber
1

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]));
}
Koray Tugay
sumber
0

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);
Ilya Gazman
sumber
0
int[] arr = { 1, 2, 3, 4, 5 };

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

lihat ini

hamidreza75
sumber