Buat ArrayList dari array

3596

Saya memiliki array yang diinisialisasi seperti:

Element[] array = {new Element(1), new Element(2), new Element(3)};

Saya ingin mengubah array ini menjadi objek ArrayListkelas.

ArrayList<Element> arraylist = ???;
Ron Tuffin
sumber
49
Di Java9 -> Daftar <String> list = List.of ("Hello", "World", "from", "Java");
MarekM
18
@ MarsekM Jawaban ini salah, karena ini tidak mengembalikan sebuah ArrayList. Poster itu meminta secara spesifik untuk itu.
Dorian Grey
4
Saya pikir dia tidak menambang menggunakan antarmuka Daftar, karena ini adalah praktik terbaik. Tetapi jika Anda ingin di sini adalah - ArrayList baru <> (List.of ("Hello", "World", "from", "Java"));
MarekM
10
Intinya bukan tentang menggunakan antarmuka, intinya adalah bahwa dalam solusi Anda, daftar yang dikembalikan tidak dapat dimodifikasi. Itu mungkin lebih dari masalah, dan alasan mengapa dia meminta ArrayList
Dorian Gray

Jawaban:

4603
new ArrayList<>(Arrays.asList(array));
Tom
sumber
361
Ya. Dan dalam kasus (paling umum) di mana Anda hanya ingin daftar, new ArrayListpanggilan juga tidak perlu.
Calum
143
@ Buron - cukup gunakanList<ClassName> list = Arrays.asList(array)
Pool
248
@ Calum dan @Pool - seperti yang tercantum di bawah dalam jawaban Alex Miller, menggunakan Arrays.asList(array)tanpa melewatkannya ke ArrayListobjek baru akan memperbaiki ukuran daftar. Salah satu alasan paling umum untuk menggunakan ArrayListadalah untuk dapat secara dinamis mengubah ukurannya, dan saran Anda akan mencegah hal ini.
Code Jockey
130
Arrays.asList () adalah fungsi yang mengerikan, dan Anda tidak boleh hanya menggunakan nilai pengembaliannya apa adanya. Itu merusak daftar Templat, jadi selalu gunakan dalam formulir yang ditunjukkan di sini, bahkan jika itu tampak berlebihan. Jawaban yang bagus.
Adam
83
@Adam Silakan pelajari javadoc untuk java.util.List. Kontrak untuk add memungkinkan mereka untuk melempar UnsupportedOperationException. docs.oracle.com/javase/7/docs/api/java/util/... Harus diakui, dari perspektif berorientasi objek, tidak terlalu baik bahwa Anda harus berkali-kali mengetahui implementasi konkret untuk menggunakan koleksi - ini adalah pilihan desain pragmatis untuk menjaga kerangka sederhana.
lbalazscs
918

Diberikan:

Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };

Jawaban paling sederhana adalah melakukan:

List<Element> list = Arrays.asList(array);

Ini akan bekerja dengan baik. Tetapi beberapa peringatan:

  1. Daftar yang dikembalikan dari asList memiliki ukuran tetap . Jadi, jika Anda ingin dapat menambah atau menghapus elemen dari daftar yang dikembalikan dalam kode Anda, Anda harus membungkusnya dengan yang baru ArrayList. Kalau tidak, Anda akan mendapatkan UnsupportedOperationException.
  2. Daftar yang dikembalikan dari asList()didukung oleh array asli. Jika Anda memodifikasi array asli, daftar akan dimodifikasi juga. Ini mungkin mengejutkan.
Alex Miller
sumber
6
Apa kompleksitas waktu dari kedua operasi? Maksud saya dengan dan tanpa menggunakan konstruksi arraylist eksplisit.
Terkutuk
35
Arrays.asList () hanya membuat ArrayList dengan membungkus array yang ada sehingga O (1).
Alex Miller
27
Membungkus dalam ArrayList baru () akan menyebabkan semua elemen dari daftar ukuran tetap untuk diiterasi dan ditambahkan ke ArrayList baru jadi O (n).
Alex Miller
8
implementasi Daftar yang dikembalikan oleh asList () tidak mengimplementasikan beberapa metode Daftar (seperti add (), hapus (), hapus (), dll ...) yang menjelaskan UnsupportedOperationException. pasti peringatan ...
sethro
8
Ketika pertanyaannya menanyakan "objek kelas ArrayList" saya pikir masuk akal untuk menganggap kelas yang dimaksud adalah java.util.ArrayList. Arrays.asList sebenarnya mengembalikan java.util.Arrays.ArrayListyang bukan instanceofkelas lain. Jadi peringatan ketiga adalah bahwa jika Anda mencoba menggunakannya dalam konteks yang memerlukan di atas itu tidak akan berfungsi.
Dave L.
352

(utas lama, tetapi hanya 2 sen karena tidak ada yang menyebutkan Guava atau lib lainnya dan beberapa detail lainnya)

Jika Anda Bisa, Gunakan Jambu Biji

Ada baiknya menunjukkan cara Guava, yang sangat menyederhanakan shenanigans ini:

Pemakaian

Untuk Daftar yang Tidak Berubah

Gunakan ImmutableListkelas dan yang of()dan copyOf()pabrik metode (unsur yang tidak dapat null) :

List<String> il = ImmutableList.of("string", "elements");  // from varargs
List<String> il = ImmutableList.copyOf(aStringArray);      // from array

Untuk Daftar Mutable

Gunakan Listskelas dan newArrayList()metode pabriknya:

List<String> l1 = Lists.newArrayList(anotherListOrCollection);    // from collection
List<String> l2 = Lists.newArrayList(aStringArray);               // from array
List<String> l3 = Lists.newArrayList("or", "string", "elements"); // from varargs

Harap perhatikan metode serupa untuk struktur data lainnya di kelas lain, misalnya di Sets.

Kenapa Jambu Biji?

Daya tarik utama dapat mengurangi kekacauan karena obat generik untuk keselamatan jenis, karena penggunaan metode pabrik Jambu memungkinkan jenis disimpulkan sebagian besar waktu. Namun, argumen ini menahan lebih sedikit air sejak Java 7 tiba dengan operator berlian baru.

Tapi itu bukan satu-satunya alasan (dan Java 7 belum ada di mana-mana): sintaks steno juga sangat berguna, dan metode inisialisasi, seperti yang terlihat di atas, memungkinkan untuk menulis kode yang lebih ekspresif. Anda dapat melakukan dalam satu panggilan Guava apa yang dibutuhkan 2 dengan Koleksi Java saat ini.


Jika Kamu Tidak Bisa ...

Untuk Daftar yang Tidak Berubah

Gunakan kelas JDK Arraysdan asList()metode pabriknya, dibungkus dengan Collections.unmodifiableList():

List<String> l1 = Collections.unmodifiableList(Arrays.asList(anArrayOfElements));
List<String> l2 = Collections.unmodifiableList(Arrays.asList("element1", "element2"));

Perhatikan bahwa tipe yang dikembalikan untuk asList()adalah Listmenggunakan ArrayListimplementasi konkret , tetapi BUKAN java.util.ArrayList . Ini adalah tipe bagian dalam, yang mengemulasi sebuah ArrayListtetapi sebenarnya secara langsung mereferensikan array yang lewat dan membuatnya "menulis" (modifikasi tercermin dalam array).

Itu melarang modifikasi melalui beberapa Listmetode API dengan cara hanya memperpanjang suatu AbstractList(jadi, menambah atau menghapus elemen tidak didukung), namun itu memungkinkan panggilan set()untuk menimpa elemen. Dengan demikian daftar ini tidak benar-benar abadi dan panggilan untuk asList()dibungkus Collections.unmodifiableList().

Lihat langkah selanjutnya jika Anda membutuhkan daftar yang dapat diubah.

Untuk Daftar Mutable

Sama seperti di atas, tetapi dibungkus dengan aktual java.util.ArrayList:

List<String> l1  = new ArrayList<String>(Arrays.asList(array));    // Java 1.5 to 1.6
List<String> l1b = new ArrayList<>(Arrays.asList(array));          // Java 1.7+
List<String> l2  = new ArrayList<String>(Arrays.asList("a", "b")); // Java 1.5 to 1.6
List<String> l2b = new ArrayList<>(Arrays.asList("a", "b"));       // Java 1.7+

Untuk Tujuan Pendidikan: Cara Manual Yang Baik

// for Java 1.5+
static <T> List<T> arrayToList(final T[] array) {
  final List<T> l = new ArrayList<T>(array.length);

  for (final T s : array) {
    l.add(s);
  }
  return (l);
}

// for Java < 1.5 (no generics, no compile-time type-safety, boo!)
static List arrayToList(final Object[] array) {
  final List l = new ArrayList(array.length);

  for (int i = 0; i < array.length; i++) {
    l.add(array[i]);
  }
  return (l);
}
haylem
sumber
27
+1 Tetapi perhatikan bahwa yang Listdikembalikan oleh Arrays.asListbisa berubah karena Anda masih bisa setelemen - itu hanya tidak dapat diubah ukurannya. Untuk daftar abadi tanpa Jambu Anda mungkin menyebutkan Collections.unmodifiableList.
Paul Bellora
1
@haylem Di bagian Anda Untuk Tujuan Pendidikan: Cara Manual yang Baik , arrayToListuntuk Java 1.5+ Anda salah. Anda membuat daftar String, dan mencoba untuk mengambil string dari array yang diberikan, daripada menggunakan tipe parameter umum T,. Selain itu, jawaban yang bagus, dan +1 untuk menjadi satu-satunya termasuk cara manual.
afsantos
Ganti nama bagian Anda "Jika Anda Tidak Dapat ... / Untuk Daftar yang Tidak Berubah" menjadi "Untuk Daftar yang tidak dapat dimodifikasi" karena dapat dimutasi dengan perubahan selanjutnya pada array yang dibungkus. Masih O(1), tetapi untuk kekekalan Anda harus membuat salinan, misalnya oleh Collections.unmodifiableList(new ArrayList<>(Arrays.asList(array))).
maaartinus
232

Karena pertanyaan ini cukup lama, saya terkejut karena belum ada yang menyarankan bentuk paling sederhana:

List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));

Pada Java 5, Arrays.asList()mengambil parameter varargs dan Anda tidak perlu membuat array secara eksplisit.

Tim Büthe
sumber
7
Secara khusus,List<String> a = Arrays.asList("first","second","third")
18446744073709551615
209
new ArrayList<T>(Arrays.asList(myArray));

Pastikan myArrayjenisnya sama dengan T. Anda akan mendapatkan kesalahan kompiler jika Anda mencoba membuat List<Integer>dari array int, misalnya.

Bill the Lizard
sumber
103

Cara lain (meskipun pada dasarnya setara dengan new ArrayList(Arrays.asList(array))solusi kinerja-bijaksana:

Collections.addAll(arraylist, array);
Peter Tseng
sumber
96

Jawa 9

Di Java 9 , Anda dapat menggunakan List.ofmetode pabrik statis untuk membuat Listliteral. Sesuatu seperti yang berikut ini:

List<Element> elements = List.of(new Element(1), new Element(2), new Element(3));

Ini akan mengembalikan daftar yang tidak berubah yang mengandung tiga elemen. Jika Anda ingindaftar yang dapat diubah , berikan daftar itu keArrayListkonstruktor:

new ArrayList<>(List.of(// elements vararg))

JEP 269: Metode Kenyamanan Pabrik untuk Koleksi

JEP 269 menyediakan beberapa metode pabrik praktis untuk Java Collections API. Metode pabrik statis abadi dibangun ke dalamList , Setdan Mapantarmuka di Jawa 9 dan kemudian.

Ali Dehghani
sumber
List.of () tidak akan mengembalikan instance dari java.util.ArrayList, seperti yang diminta dalam pertanyaan asli. Karena itu hanya opsi kedua yang merupakan jawaban yang valid.
tquadrat
84

Anda mungkin hanya perlu Daftar, bukan ArrayList. Dalam hal ini Anda hanya dapat melakukan:

List<Element> arraylist = Arrays.asList(array);
Tidur
sumber
8
Itu akan didukung oleh array input asli, itulah sebabnya Anda (mungkin) ingin membungkusnya dalam ArrayList baru.
Bill the Lizard
16
Hati-hati dengan solusi ini. Jika Anda melihat, Array TIDAK mengembalikan java.util.ArrayList yang benar. Ini mengembalikan kelas batin yang mengimplementasikan metode yang diperlukan, tetapi Anda tidak dapat mengubah memebers dalam daftar. Ini hanyalah pembungkus array.
Mikezx6r
1
Anda dapat melemparkan item Daftar <Element> ke ArrayList <Element>
monksy
12
@ Mikezx6r: sedikit koreksi : ini adalah daftar ukuran tetap. Anda dapat mengubah elemen daftar ( setmetode), Anda tidak dapat mengubah ukuran daftar (bukan addatau removeelemen)!
user85421
1
Ya, dengan peringatan itu tergantung pada apa yang ingin Anda lakukan dengan daftar. Perlu dicatat bahwa jika OP hanya ingin beralih melalui elemen, array tidak harus dikonversi sama sekali.
PaulMurrayCbr
69

Pembaruan lain, hampir berakhir tahun 2014, Anda juga dapat melakukannya dengan Java 8:

ArrayList<Element> arrayList = Stream.of(myArray).collect(Collectors.toCollection(ArrayList::new));

Beberapa karakter akan disimpan, jika ini bisa saja a List

List<Element> list = Stream.of(myArray).collect(Collectors.toList());
kenapa
sumber
8
Mungkin yang terbaik adalah tidak bergantung pada implementasi, tetapi Collectors.toList()sebenarnya mengembalikan sebuah ArrayList.
bcsb1001
salah menggunakan Stream.of (...); yang akan membuat aliran satu elemen. Gunakan Arrays.stream sebagai gantinya
Patrick Parker
Saya tidak berpikir begitu, 2 opsi tersebut valid tetapi Arrays.stream sedikit 'lebih baik' karena Anda dapat membuatnya dengan ukuran tetap, menggunakan metode overload dengan 'start', 'end' args. Lihat juga: stackoverflow.com/a/27888447/2619091
whyem
41

Jika Anda menggunakan:

new ArrayList<T>(Arrays.asList(myArray));

Anda dapat membuat dan mengisi dua daftar! Mengisi dua kali daftar besar adalah persis apa yang tidak ingin Anda lakukan karena itu akan membuat Object[]array lain setiap kali kapasitas perlu diperpanjang.

Untungnya implementasi JDK cepat dan Arrays.asList(a[])dilakukan dengan sangat baik. Itu membuat semacam ArrayList bernama Arrays.ArrayList di mana data Object [] menunjuk langsung ke array.

// in Arrays
@SafeVarargs
public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}
//still in Arrays, creating a private unseen class
private static class ArrayList<E>

    private final E[] a;    
    ArrayList(E[] array) {
        a = array; // you point to the previous array
    }
    ....
}

Sisi berbahaya adalah bahwa jika Anda mengubah array awal, Anda mengubah Daftar!Anda yakin ingin itu? Mungkin ya mungkin tidak.

Jika tidak, cara yang paling bisa dipahami adalah melakukan ini:

ArrayList<Element> list = new ArrayList<Element>(myArray.length); // you know the initial capacity
for (Element element : myArray) {
    list.add(element);
}

Atau seperti kata @glglgl, Anda dapat membuat ArrayList independen lain dengan:

new ArrayList<T>(Arrays.asList(myArray));

Saya suka menggunakan Collections, Arraysatau jambu. Tetapi jika itu tidak cocok, atau Anda tidak merasakannya, tulis saja baris lain yang tidak menarik.

Nicolas Zozol
sumber
1
Saya gagal melihat perbedaan mendasar antara loop Anda di akhir jawaban dan new ArrayList<T>(Arrays.asList(myArray));bagian yang Anda tidak ingin gunakan. Keduanya melakukan hal yang sama dan memiliki kompleksitas yang sama.
glglgl
Koleksi satu membuat pointer di awal array. Loop saya membuat banyak pointer: satu untuk setiap anggota array. Jadi jika array asli berubah, poiner saya masih diarahkan ke nilai sebelumnya.
Nicolas Zozol
1
new ArrayList<T>(Arrays.asList(myArray));melakukan hal yang sama, ini menyalin asListke ArrayList...
glglgl
37

Di dalam Java 9Anda dapat menggunakan:

List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);
MarekM
sumber
Perhatikan bahwa ini bukan ArrayList, seperti yang diminta secara eksplisit.
Dorian Gray
33

Menurut pertanyaan, jawabannya menggunakan java 1.7 adalah:

ArrayList<Element> arraylist = new ArrayList<Element>(Arrays.<Element>asList(array));

Namun lebih baik selalu menggunakan antarmuka:

List<Element> arraylist = Arrays.<Element>asList(array);
nekperu15739
sumber
30
// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray); 
Bohdan
sumber
21

karena semua mengatakan ini akan melakukannya

 new ArrayList<>(Arrays.asList("1","2","3","4"));

dan cara terbaru umum untuk membuat array adalah observableArrays

Daftar Teramati: Daftar yang memungkinkan pendengar melacak perubahan saat itu terjadi.

untuk Java SE Anda dapat mencoba

FXCollections.observableArrayList(new Element(1), new Element(2), new Element(3));

itu menurut Oracle Docs

observableArrayList () Membuat daftar kosong baru yang dapat diobservasi yang didukung oleh daftar array. observableArrayList (E ... items) Membuat daftar array yang dapat diamati baru dengan item yang ditambahkan padanya.

Perbarui Java 9

juga di Java 9 itu sedikit mudah:

List<String> list = List.of("element 1", "element 2", "element 3");
Abojemyeg
sumber
20

Karena Java 8 ada cara yang lebih mudah untuk mengubah:

public static <T> List<T> fromArray(T[] array) {
    return Arrays.stream(array).collect(toList());
}
Andrii Abramov
sumber
18

Anda juga dapat melakukannya dengan streaming di Java 8.

 List<Element> elements = Arrays.stream(array).collect(Collectors.toList()); 
Vaseph
sumber
3
Pada java 8 , Collectors.toList()akan mengembalikan sebuah ArrayList. Namun ini mungkin berbeda di versi masa depan di java. Jika Anda ingin jenis koleksi tertentu kemudian gunakan di Collectors.toCollection()mana Anda dapat menentukan jenis koleksi yang tepat yang ingin Anda buat.
Raja Anbazhagan
14
  1. Jika kita melihat definisi Arrays.asList()metode, Anda akan mendapatkan sesuatu seperti ini:

     public static <T> List<T> asList(T... a) //varargs are of T type. 

    Jadi, Anda dapat menginisialisasi arraylistseperti ini:

     List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));

    Catatan : masing new Element(int args)- masing akan diperlakukan sebagai Objek Individual dan dapat dilewatkan sebagai a var-args.

  2. Mungkin ada jawaban lain untuk pertanyaan ini juga.
    Jika Anda melihat deklarasi untuk java.util.Collections.addAll()metode, Anda akan mendapatkan sesuatu seperti ini:

    public static <T> boolean addAll(Collection<? super T> c, T... a);

    Jadi, kode ini juga berguna untuk melakukannya

    Collections.addAll(arraylist, array);
Vikrant Kashyap
sumber
10

Cara sederhana lain adalah menambahkan semua elemen dari array ke ArrayList baru menggunakan untuk setiap loop.

ArrayList<Element> list = new ArrayList<>();

for(Element e : array)
    list.add(e);
spencer.sm
sumber
10

Jika array adalah tipe primitif, jawaban yang diberikan tidak akan berfungsi. Tetapi karena Java 8 Anda dapat menggunakan:

int[] array = new int[5];
Arrays.stream(array).boxed().collect(Collectors.toList());
A1m
sumber
solusi ini juga tidak bekerja dengan chararray.
PixelMaster
8

Anda dapat melakukannya di java 8 sebagai berikut

ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());
Adit A. Pillai
sumber
1
Turun karena pemeran itu terlihat sangat berbahaya. tidak ada yang menentukan bahwa jenis daftar yang dikembalikan sebenarnya adalah ArrayList, seperti yang dinyatakan javadoc: "Tidak ada jaminan pada jenis, mutabilitas, serializability, atau keamanan benang dari Daftar yang dikembalikan"
Dorian Gray
1
Jika Anda ingin secara eksplisit membuat ArrayList, coba ini:ArrayList<String> list = Arrays.stream(array).collect(Collectors.toCollection(ArrayList::new));
Dorian Gray
8

Kita dapat dengan mudah mengonversi array menjadi ArrayList. Kami menggunakan addAll()metode Koleksi antarmuka untuk tujuan menyalin konten dari satu daftar ke yang lain.

 Arraylist arr = new Arraylist();
 arr.addAll(Arrays.asList(asset));
ruam
sumber
Ini kurang efisien daripada jawaban yang diterima 9 tahun.
AjahnCharles
2
Salah satu ArrayListkonstruktor menerima ? extends Collection<T>argumen, membuat panggilan menjadi addAllmubazir.
Tamoghna Chowdhury
7

Meskipun ada banyak jawaban yang ditulis dengan sempurna untuk pertanyaan ini, saya akan menambahkan masukan saya.

Katakan sudah Element[] array = { new Element(1), new Element(2), new Element(3) };

ArrayList baru dapat dibuat dengan cara berikut

ArrayList<Element> arraylist_1 = new ArrayList<>(Arrays.asList(array));
ArrayList<Element> arraylist_2 = new ArrayList<>(
    Arrays.asList(new Element[] { new Element(1), new Element(2), new Element(3) }));

// Add through a collection
ArrayList<Element> arraylist_3 = new ArrayList<>();
Collections.addAll(arraylist_3, array);

Dan mereka sangat mendukung semua operasi ArrayList

arraylist_1.add(new Element(4)); // or remove(): Success
arraylist_2.add(new Element(4)); // or remove(): Success
arraylist_3.add(new Element(4)); // or remove(): Success

Tetapi operasi berikut mengembalikan hanya tampilan daftar ArrayList dan bukan ArrayList yang sebenarnya.

// Returns a List view of array and not actual ArrayList
List<Element> listView_1 = (List<Element>) Arrays.asList(array);
List<Element> listView_2 = Arrays.asList(array);
List<Element> listView_3 = Arrays.asList(new Element(1), new Element(2), new Element(3));

Oleh karena itu, mereka akan memberikan kesalahan ketika mencoba membuat beberapa operasi ArrayList

listView_1.add(new Element(4)); // Error
listView_2.add(new Element(4)); // Error
listView_3.add(new Element(4)); // Error

Lebih lanjut tentang Representasi daftar tautan larik .

Devendra Lattu
sumber
7

Cara paling sederhana untuk melakukannya adalah dengan menambahkan kode berikut. Sudah Mencoba dan Diuji.

String[] Array1={"one","two","three"};
ArrayList<String> s1= new ArrayList<String>(Arrays.asList(Array1));
Hemin
sumber
7

Solusi Java8 lain (saya mungkin telah melewatkan jawaban di antara set besar. Jika demikian, saya minta maaf). Ini menciptakan ArrayList (sebagai lawan dari Daftar) yaitu seseorang dapat menghapus elemen

package package org.something.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Junk {

    static <T> ArrayList<T>  arrToArrayList(T[] arr){
        return Arrays.asList(arr)
            .stream()
            .collect(Collectors.toCollection(ArrayList::new));
    }

    public static void main(String[] args) {
        String[] sArr = new String[]{"Hello", "cruel", "world"};
        List<String> ret = arrToArrayList(sArr);
        // Verify one can remove an item and print list to verify so
        ret.remove(1);
        ret.stream()
            .forEach(System.out::println);
    }
}

Outputnya adalah ...
Halo
dunia

Pelihat ompong
sumber
7

Gunakan kode berikut untuk mengubah array elemen menjadi ArrayList.

Element[] array = {new Element(1), new Element(2), new Element(3)};

ArrayList<Element>elementArray=new ArrayList();
for(int i=0;i<array.length;i++) {
    elementArray.add(array[i]);
}
Kavinda Pushpitha
sumber
5

Sudah semua orang memberikan jawaban yang cukup baik untuk masalah Anda. Sekarang dari semua saran, Anda harus memutuskan mana yang sesuai dengan kebutuhan Anda. Ada dua jenis koleksi yang perlu Anda ketahui. Satu adalah koleksi yang tidak dimodifikasi dan satu lagi koleksi yang akan memungkinkan Anda untuk memodifikasi objek nanti.

Jadi, Di sini saya akan memberikan contoh singkat untuk dua kasus penggunaan.

  • Pembuatan koleksi tidak berubah :: Ketika Anda tidak ingin mengubah objek koleksi setelah pembuatan

    List<Element> elementList = Arrays.asList(array)

  • Pembuatan koleksi yang dapat diubah :: Bila Anda mungkin ingin memodifikasi objek koleksi yang dibuat setelah pembuatan.

    List<Element> elementList = new ArrayList<Element>(Arrays.asList(array));

Sumit Das
sumber
List <Element> elementList = Arrays.asList (array) membuat pembungkus atas array asli yang membuat array asli tersedia sebagai Daftar. Oleh karena itu objek wrapper dibuat, tidak ada yang disalin dari array asli. Oleh karena itu, operasi seperti menambah atau menghapus elemen tidak diperbolehkan.
Priyanka
3
Perhatikan bahwa "koleksi tidak berubah" Anda tidak benar-benar tidak dapat diubah - yang Listdikembalikan oleh Arrays.asListhanya pembungkus atas array asli, dan memungkinkan setiap item diakses dan dimodifikasi melalui getdan set. Anda mungkin harus mengklarifikasi bahwa maksud Anda "tidak menambah atau menghapus elemen" alih-alih "tidak berubah", yang berarti tidak berubah sama sekali.
Tamoghna Chowdhury
5

Array Objek yang Diberikan:

Element[] array = {new Element(1), new Element(2), new Element(3) , new Element(2)};

Konversi Array ke Daftar:

    List<Element> list = Arrays.stream(array).collect(Collectors.toList());

Konversi Array ke ArrayList

    ArrayList<Element> arrayList = Arrays.stream(array)
                                       .collect(Collectors.toCollection(ArrayList::new));

Konversi Array ke LinkedList

    LinkedList<Element> linkedList = Arrays.stream(array)
                     .collect(Collectors.toCollection(LinkedList::new));

Daftar cetak:

    list.forEach(element -> {
        System.out.println(element.i);
    });

KELUARAN

1

2

3

Arpan Saini
sumber
4

Kelas Array Java 8 menyediakan metode stream () yang memiliki versi overload yang menerima array primitif dan array Obyek.

/**** Converting a Primitive 'int' Array to List ****/

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

List<Integer> integerList1 = Arrays.stream(intArray).boxed().collect(Collectors.toList());

/**** 'IntStream.of' or 'Arrays.stream' Gives The Same Output ****/

List<Integer> integerList2 = IntStream.of(intArray).boxed().collect(Collectors.toList());

/**** Converting an 'Integer' Array to List ****/

Integer integerArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

List<Integer> integerList3 = Arrays.stream(integerArray).collect(Collectors.toList());
Himanshu Dave
sumber
3

Kode di bawah ini sepertinya cara yang bagus untuk melakukan ini.

new ArrayList<T>(Arrays.asList(myArray));
Singh123
sumber