Konversi array ke daftar di Jawa

Bagaimana cara mengubah array ke daftar di Jawa?

Saya menggunakan Arrays.asList()tetapi perilaku (dan tanda tangan) entah bagaimana berubah dari Java SE 1.4.2 (sekarang dalam arsip) ke 8 dan sebagian besar cuplikan yang saya temukan di web menggunakan perilaku 1.4.2.

Sebagai contoh:

int[] spam = new int[] { 1, 2, 3 };
Arrays.asList(spam)

• pada 1.4.2 mengembalikan daftar yang berisi elemen 1, 2, 3
• pada 1.5.0+ mengembalikan daftar yang berisi spam array

Dalam banyak kasus seharusnya mudah untuk dideteksi, tetapi kadang-kadang bisa tidak diketahui:

Assert.assertTrue(Arrays.asList(spam).indexOf(4) == -1);

Dalam contoh Anda, itu karena Anda tidak dapat memiliki Daftar tipe primitif. Dengan kata lain, List<int>itu tidak mungkin.

Namun, Anda dapat List<Integer>menggunakan Integerkelas yang membungkus intprimitif. Konversi array Anda menjadi Listdengan Arrays.asListmetode utilitas.

Integer[] spam = new Integer[] { 1, 2, 3 };
List<Integer> list = Arrays.asList(spam);

Lihat kode ini berjalan langsung di IdeOne.com .

Di Java 8, Anda dapat menggunakan stream:

int[] spam = new int[] { 1, 2, 3 };
Arrays.stream(spam)
      .boxed()
      .collect(Collectors.toList());

Berbicara tentang cara konversi, itu tergantung pada mengapa Anda memerlukannya List. Jika Anda membutuhkannya hanya untuk membaca data. Oke, ini dia:

Integer[] values = { 1, 3, 7 };
List<Integer> list = Arrays.asList(values);

Tetapi jika Anda melakukan sesuatu seperti ini:

list.add(1);

kamu dapatkan java.lang.UnsupportedOperationException. Jadi untuk beberapa kasus Anda bahkan memerlukan ini:

Integer[] values = { 1, 3, 7 };
List<Integer> list = new ArrayList<Integer>(Arrays.asList(values));

Pendekatan pertama sebenarnya tidak mengubah array tetapi 'mewakili' seperti List. Tetapi array berada di bawah tenda dengan semua propertinya seperti jumlah elemen yang tetap. Harap perhatikan bahwa Anda perlu menentukan tipe saat membuat ArrayList.

Masalahnya adalah bahwa Arrays.asList()vararg diperkenalkan di Java5 dan sayangnya, kelebihan beban dengan versi vararg juga. Jadi Arrays.asList(spam)dipahami oleh kompiler Java5 sebagai parameter vararg dari array int.

Masalah ini dijelaskan secara lebih terperinci dalam Effective Java 2nd Ed., Bab 7, Item 42.

Tampaknya sedikit terlambat tetapi ini adalah dua sen saya. Kita tidak dapat memiliki List<int>sebagai intadalah tipe primitif sehingga kita hanya dapat memiliki List<Integer>.

Java 8 (int array)

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

Java 8 dan yang lebih baru (array Integer)

Integer[] integers = new Integer[] {1,2,3,4,5};
List<Integer> list21 =  Arrays.asList(integers); // returns a fixed-size list backed by the specified array.
List<Integer> list22 = new ArrayList<>(Arrays.asList(integers)); // good
List<Integer> list23 = Arrays.stream(integers).collect(Collectors.toList()); //Java 8 only

Perlu ArrayList dan bukan Daftar?

Jika kita menginginkan implementasi spesifik dari Listeg ArrayListmaka kita dapat menggunakan toCollectionsebagai:

ArrayList<Integer> list24 = Arrays.stream(integers)
                          .collect(Collectors.toCollection(ArrayList::new));

Mengapa list21tidak dapat dimodifikasi secara struktural?

Ketika kita menggunakan Arrays.asListukuran daftar yang dikembalikan adalah tetap karena daftar yang dikembalikan bukan java.util.ArrayList, tetapi kelas statis pribadi yang didefinisikan di dalamnya java.util.Arrays. Jadi jika kita menambah atau menghapus elemen dari daftar yang dikembalikan, sebuah UnsupportedOperationExceptionakan dilempar. Jadi kita harus pergi list22ketika kita ingin mengubah daftar. Jika kita memiliki Java8 maka kita juga bisa menggunakannya list23.

Agar jelas list21dapat dimodifikasi dalam arti bahwa kita dapat memanggil list21.set(index,element)tetapi daftar ini mungkin tidak dimodifikasi secara struktural yaitu tidak dapat menambah atau menghapus elemen dari daftar. Anda juga dapat memeriksa pertanyaan ini .

Jika kita menginginkan daftar yang tidak dapat diubah maka kita dapat membungkusnya sebagai:

List<Integer> list 22 = Collections.unmodifiableList(Arrays.asList(integers));

Hal lain yang perlu diperhatikan adalah bahwa metode ini Collections.unmodifiableListmengembalikan tampilan daftar yang ditentukan yang tidak dapat dimodifikasi. Koleksi tampilan yang tidak dapat dimodifikasi adalah koleksi yang tidak dapat dimodifikasi dan juga merupakan tampilan ke koleksi dukungan. Perhatikan bahwa perubahan pada koleksi dukungan mungkin masih dimungkinkan, dan jika terjadi, mereka dapat dilihat melalui tampilan yang tidak dapat dimodifikasi.

Kita dapat memiliki daftar yang benar-benar abadi di Jawa 9 dan 10.

Daftar yang benar-benar tidak dapat berubah

Java 9:

String[] objects = {"Apple", "Ball", "Cat"};
List<String> objectList = List.of(objects);

Java 10 (Daftar Benar-Benar Tidak Berubah) dalam dua cara:

1. List.copyOf(Arrays.asList(integers))
2. Arrays.stream(integers).collect(Collectors.toUnmodifiableList());

Periksa juga jawaban saya ini untuk informasi lebih lanjut.

Bahkan lebih pendek:

List<Integer> list = Arrays.asList(1, 2, 3, 4);

Baru-baru ini saya harus mengubah array ke Daftar. Kemudian program menyaring daftar yang berusaha menghapus data. Saat Anda menggunakan fungsi Arrays.asList (array), Anda membuat koleksi ukuran tetap: Anda tidak bisa menambah atau menghapus. Entri ini menjelaskan masalah lebih baik daripada yang saya bisa: Mengapa saya mendapatkan UnsupportedOperationException ketika mencoba menghapus elemen dari Daftar? .

Pada akhirnya, saya harus melakukan konversi "manual":

    List<ListItem> items = new ArrayList<ListItem>();
    for (ListItem item: itemsArray) {
        items.add(item);
    }

Saya kira saya bisa menambahkan konversi dari array ke daftar menggunakan operasi List.addAll (item).

Menggunakan Array

Ini adalah cara paling sederhana untuk mengonversi array menjadi List. Namun, jika Anda mencoba menambahkan elemen baru atau menghapus elemen yang ada dari daftar, sebuah UnsupportedOperationExceptionakan dilempar.

Integer[] existingArray = {1, 2, 3};
List<Integer> list1 = Arrays.asList(existingArray);
List<Integer> list2 = Arrays.asList(1, 2, 3);

// WARNING:
list2.add(1);     // Unsupported operation!
list2.remove(1);  // Unsupported operation!

Menggunakan ArrayList atau Implementasi Daftar Lainnya

Anda bisa menggunakan forloop untuk menambahkan semua elemen array ke dalam Listimplementasi, misalnya ArrayList:

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

Menggunakan Stream API di Java 8

Anda bisa mengubah array menjadi stream, lalu kumpulkan stream menggunakan kolektor berbeda: Kolektor default di Java 8 menggunakan di ArrayListbelakang layar, tetapi Anda juga bisa memaksakan implementasi yang Anda inginkan.

List<Integer> list1, list2, list3;
list1 = Stream.of(1, 2, 3).collect(Collectors.toList());
list2 = Stream.of(1, 2, 3).collect(Collectors.toCollection(ArrayList::new));
list3 = Stream.of(1, 2, 3).collect(Collectors.toCollection(LinkedList::new));

Lihat juga:

• Mengapa kami menggunakan autoboxing dan unboxing di Java?
• Kapan harus menggunakan LinkedList daripada ArrayList?

Solusi lain jika Anda menggunakan apache commons-lang:

int[] spam = new int[] { 1, 2, 3 };
Arrays.asList(ArrayUtils.toObject(spam));

Di mana ArrayUtils.toObject dikonversi int[]menjadiInteger[]

Anda harus memasukkan ke dalam array

Arrays.asList((Object[]) array)

Satu-liner:

List<Integer> list = Arrays.asList(new Integer[] {1, 2, 3, 4});

Di Java 9 Anda memiliki solusi yang lebih elegan menggunakan daftar abadi melalui metode pabrik kenyamanan baru List.of:

List<String> immutableList = List.of("one","two","three");

(Tanpa malu-malu disalin dari sini )

Jika Anda menargetkan Java 8 (atau lebih baru), Anda dapat mencoba ini:

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

CATATAN:

Perhatikan Collectors.<Integer>toList(), metode umum ini membantu Anda menghindari kesalahan "Ketik ketidakcocokan: tidak dapat dikonversi dari List<Object>ke List<Integer>".

1. Menggunakan jambu biji:

   Integer[] array = { 1, 2, 3};
   List<Integer> list = Lists.newArrayList(sourceArray);

2. Menggunakan Koleksi Apache Commons:

   Integer[] array = { 1, 2, 3};
   List<Integer> list = new ArrayList<>(6);
   CollectionUtils.addAll(list, array);

Jika ini membantu: Saya memiliki masalah yang sama dan hanya menulis fungsi generik yang mengambil array dan mengembalikan ArrayList dari tipe yang sama dengan konten yang sama:

public static <T> ArrayList<T> ArrayToArrayList(T[] array) {
    ArrayList<T> list = new ArrayList<T>();
    for(T elmt : array) list.add(elmt);
    return list;
}

Array yang Diberikan:

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

Mengubah array integer ke Daftar Integer

Satu cara: boxed () -> mengembalikan IntStream

    List<Integer> givenIntArray1 = Arrays.stream(givenArray)
                                  .boxed()
                                  .collect(Collectors.toList());

Cara Kedua: memetakan setiap elemen aliran ke Integer dan kemudian mengumpulkan

CATATAN: Menggunakan mapToObj, Anda dapat menyamarkan setiap elemen int ke dalam string stream, char stream, dll dengan casing i to (char) i

    List<Integer> givenIntArray2 = Arrays.stream(givenArray)
                                         .mapToObj(i->i)
                                         .collect(Collectors.toList());

Mengubah Satu Jenis Array ke Jenis Lain Contoh:

List<Character> givenIntArray2 = Arrays.stream(givenArray)
                                             .mapToObj(i->(char)i)
                                             .collect(Collectors.toList());

Jadi itu tergantung pada versi Java yang Anda coba-

Java 7

 Arrays.asList(1, 2, 3);

ATAU

       final String arr[] = new String[] { "G", "E", "E", "K" };
       final List<String> initialList = new ArrayList<String>() {{
           add("C");
           add("O");
           add("D");
           add("I");
           add("N");
       }};

       // Elements of the array are appended at the end
       Collections.addAll(initialList, arr);

ATAU

Integer[] arr = new Integer[] { 1, 2, 3 };
Arrays.asList(arr);

Di Jawa 8

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

Referensi - http://www.codingeek.com/java/how-to-convert-array-to-list-in-java/

Bisakah Anda meningkatkan jawaban ini karena ini adalah apa yang saya gunakan tetapi saya tidak 100% jelas. Ini berfungsi dengan baik tetapi intelliJ menambahkan WeatherStation baru [0]. Mengapa 0?

    public WeatherStation[] removeElementAtIndex(WeatherStation[] array, int index)
    {
        List<WeatherStation> list = new ArrayList<WeatherStation>(Arrays.asList(array));
        list.remove(index);
        return list.toArray(new WeatherStation[0]);
    }

menggunakan dua baris kode untuk mengkonversi array ke daftar jika Anda menggunakannya dalam nilai integer Anda harus menggunakan tipe autoboxing untuk tipe data primitif

  Integer [] arr={1,2};
  Arrays.asList(arr);