Java 9 memperkenalkan metode pabrik baru untuk daftar, List.of:

List<String> strings = List.of("first", "second");

Apa perbedaan antara opsi sebelumnya dan baru? Artinya, apa perbedaan antara ini:

Arrays.asList(1, 2, 3);

dan ini:

List.of(1, 2, 3);

Arrays.asListmengembalikan daftar yang bisa berubah sementara daftar yang dikembalikan oleh tidakList.of bisa diubah :

List<Integer> list = Arrays.asList(1, 2, null);
list.set(1, 10); // OK

List<Integer> list = List.of(1, 2, 3);
list.set(1, 10); // Fails with UnsupportedOperationException

Arrays.asListmemungkinkan elemen nol sementara List.oftidak:

List<Integer> list = Arrays.asList(1, 2, null); // OK
List<Integer> list = List.of(1, 2, null); // Fails with NullPointerException

contains berperilaku berbeda dengan nulls:

List<Integer> list = Arrays.asList(1, 2, 3);
list.contains(null); // Returns false

List<Integer> list = List.of(1, 2, 3);
list.contains(null); // Fails with NullPointerException

Arrays.asListmengembalikan tampilan dari larik yang dilewati, sehingga perubahan pada larik juga akan tercermin dalam daftar. Karena List.ofini tidak benar:

Integer[] array = {1,2,3};
List<Integer> list = Arrays.asList(array);
array[1] = 10;
System.out.println(list); // Prints [1, 10, 3]

Integer[] array = {1,2,3};
List<Integer> list = List.of(array);
array[1] = 10;
System.out.println(list); // Prints [1, 2, 3]

Perbedaan antara Arrays.asListdanList.of

Lihat JavaDocs dan pembicaraan ini oleh Stuart Marks (atau versi sebelumnya).

Saya akan menggunakan yang berikut ini untuk contoh kode:

List<Integer> listOf = List.of(...);
List<Integer> asList = Arrays.asList(...);
List<Integer> unmodif = Collections.unmodifiableList(asList);

Kekekalan struktural (Atau: tidak dapat dimodifikasi)

Setiap upaya untuk mengubah strukturList.of akan menghasilkan file UnsupportedOperationException. Itu termasuk operasi seperti menambah , mengatur , dan menghapus . Namun, Anda dapat mengubah konten objek dalam daftar (jika objek tersebut tidak dapat diubah), sehingga daftar tersebut tidak "sepenuhnya tidak dapat diubah".

Ini adalah nasib yang sama untuk daftar yang tidak dapat dimodifikasi yang dibuat dengan Collections.unmodifiableList. Hanya daftar ini yang merupakan tampilan dari daftar asli, sehingga dapat berubah jika Anda mengubah daftar aslinya.

Arrays.asListtidak sepenuhnya tidak berubah, tidak ada batasan set.

listOf.set(1, "a");  // UnsupportedOperationException
unmodif.set(1, "a"); // UnsupportedOperationException
asList.set(1, "a");  // modified unmodif! unmodif is not truly unmodifiable

Demikian pula, mengubah larik pendukung (jika Anda menahannya) akan mengubah daftar.

Kekekalan struktural hadir dengan banyak efek samping yang terkait dengan pengkodean pertahanan, konkurensi, dan keamanan yang berada di luar cakupan jawaban ini.

Permusuhan nol

List.ofdan koleksi apa pun sejak Java 1.5 tidak mengizinkannya nullsebagai elemen. Mencoba meneruskan nullsebagai elemen atau bahkan pencarian akan menghasilkan file NullPointerException.

Karena Arrays.asListmerupakan koleksi dari 1.2 (Collections Framework), memungkinkan nulls.

listOf.contains(null);  // NullPointerException
unmodif.contains(null); // allowed
asList.contains(null);  // allowed

Bentuk berseri

Karena List.oftelah diperkenalkan di Java 9 dan daftar yang dibuat dengan metode ini memiliki bentuk serialnya sendiri (biner), daftar tersebut tidak dapat dideserialisasi pada versi JDK sebelumnya (tanpa kompatibilitas biner ). Namun, Anda dapat membatalkan / membuat serial dengan JSON, misalnya.

Identitas

Arrays.asListpanggilan internal new ArrayList, yang menjamin ketidaksetaraan referensi.

List.oftergantung pada implementasi internal. Instans yang dikembalikan dapat memiliki persamaan referensi, tetapi karena ini tidak dijamin, Anda tidak dapat mengandalkannya.

asList1 == asList2; // false
listOf1 == listOf2; // true or false

Perlu disebutkan bahwa daftar adalah sama (melalui List.equals) jika mereka berisi elemen yang sama dalam urutan yang sama, terlepas dari bagaimana mereka dibuat atau operasi apa yang mereka dukung.

asList.equals(listOf); // true i.f.f. same elements in same order

Implementasi (peringatan: detail dapat berubah seiring versi)

Jika jumlah elemen dalam daftar List.of2 atau kurang, elemen disimpan di bidang kelas khusus (internal). Contohnya adalah daftar yang menyimpan 2 elemen (sumber parsial):

static final class List2<E> extends AbstractImmutableList<E> {
    private final E e0;
    private final E e1;

    List2(E e0, E e1) {
        this.e0 = Objects.requireNonNull(e0);
        this.e1 = Objects.requireNonNull(e1);
    }
}

Jika tidak, mereka disimpan dalam larik dengan cara yang mirip dengan Arrays.asList.

Efisiensi Ruang dan Waktu

The List.ofimplementasi yang berbasis lapangan (ukuran <2) melakukan sedikit lebih cepat pada beberapa operasi. Sebagai contoh, size()dapat mengembalikan konstanta tanpa mengambil panjang array, dan contains(E e)tidak memerlukan overhead iterasi.

Membuat daftar yang tidak dapat dimodifikasi melalui List.ofjuga lebih cepat. Bandingkan konstruktor di atas dengan 2 tugas referensi (dan bahkan satu untuk jumlah elemen yang berubah-ubah) ke

Collections.unmodifiableList(Arrays.asList(...));

yang membuat 2 daftar ditambah biaya tambahan lainnya. Dalam hal ruang, Anda menghemat UnmodifiableListpembungkus ditambah beberapa sen. Pada akhirnya, penghematan yang HashSetsetara lebih meyakinkan.

Waktu kesimpulan: gunakan List.ofketika Anda menginginkan daftar yang tidak berubah dan Arrays.asListketika Anda menginginkan daftar yang dapat berubah (seperti yang ditunjukkan di atas).

Mari kita rangkum perbedaan antara List.of dan Arrays.asList

1. List.ofdapat digunakan paling baik jika kumpulan data lebih sedikit dan tidak berubah, sementara Arrays.asListdapat digunakan paling baik jika kumpulan data besar dan dinamis.

2. List.ofmengambil ruang overhead yang sangat sedikit karena memiliki implementasi berbasis lapangan dan mengonsumsi lebih sedikit ruang heap, baik dalam hal overhead tetap dan pada basis per elemen. sementara Arrays.asListmengambil lebih banyak ruang overhead karena saat inisialisasi, ini membuat lebih banyak objek di heap.

3. Koleksi yang dikembalikan oleh List.oftidak dapat diubah dan karenanya aman untuk thread sementara Koleksi yang dikembalikan oleh Arrays.asListdapat berubah dan tidak aman untuk thread. (Instans pengumpulan yang tidak dapat diubah umumnya mengkonsumsi lebih sedikit memori daripada rekan mereka yang dapat berubah.)

4. List.oftidak mengizinkan elemen nol sementara Arrays.asListmemungkinkan elemen nol .

Terlepas dari jawaban di atas ada operasi tertentu yang baik List::ofdan Arrays::asListberbeda:

+----------------------+---------------+----------+----------------+---------------------+
|      Operations      | SINGLETONLIST | LIST::OF | ARRAYS::ASLIST | JAVA.UTIL.ARRAYLIST |
+----------------------+---------------+----------+----------------+---------------------+
|          add         |       ❌      |     ❌  |        ❌      |          ✔️          |
+----------------------+---------------+----------+----------------+---------------------+
|        addAll        |       ❌      |     ❌  |        ❌      |          ✔️          |
+----------------------+---------------+----------+----------------+---------------------+
|         clear        |       ❌      |     ❌  |        ❌      |          ✔️          |
+----------------------+---------------+----------+----------------+---------------------+
|        remove        |       ❌      |     ❌  |        ❌      |          ✔️          |
+----------------------+---------------+----------+----------------+---------------------+
|       removeAll      |       ❗️       |     ❌   |        ❗️       |          ✔️          |
+----------------------+---------------+----------+----------------+---------------------+
|       retainAll      |       ❗️       |     ❌  |        ❗️        |          ✔️          |
+----------------------+---------------+----------+----------------+---------------------+
|      replaceAll      |       ❌      |     ❌  |        ✔️       |          ✔️          |
+----------------------+---------------+----------+----------------+---------------------+
|          set         |       ❌      |     ❌  |        ✔️       |          ✔️          |
+----------------------+---------------+----------+----------------+---------------------+
|         sort         |       ✔️       |     ❌   |        ✔️      |          ✔️          |
+----------------------+---------------+----------+----------------+---------------------+
|  remove on iterator  |       ❌      |     ❌  |        ❌      |          ✔️          |
+----------------------+---------------+----------+----------------+---------------------+
| set on list-iterator |       ❌      |     ❌  |        ✔️       |          ✔️          |
+----------------------+---------------+----------+----------------+---------------------+

1. ✔️ berarti metode ini didukung
2. ❌ berarti memanggil metode ini akan memunculkan UnsupportedOperationException
3. ❗️ berarti metode ini didukung hanya jika argumen metode tidak menyebabkan mutasi, misalnya Collections.singletonList ("foo"). RetretAll ("foo") tidak apa-apa tetapi Collections.singletonList ("foo"). RetretAll ("bar" ) melempar UnsupportedOperationException

Lebih lanjut tentang Koleksi :: singletonList Vs. Daftar