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 = ???;

new ArrayList<>(Arrays.asList(array));

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.

^{(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);
}

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.

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.

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

Collections.addAll(arraylist, array);

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.

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

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

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

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.

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

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

// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray); 

Anda dapat mengonversi menggunakan metode yang berbeda

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

2. List<Element> list = new ArrayList();
Collections.addAll(list, array);

3. Arraylist list = new Arraylist();
list.addAll(Arrays.asList(array));

Untuk detail lebih lanjut Anda bisa merujuk ke http://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html

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

Karena Java 8 ada cara yang lebih mudah untuk mengubah:

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

Anda juga dapat melakukannya dengan streaming di Java 8.

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

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

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

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

Anda dapat melakukannya di java 8 sebagai berikut

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

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

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 .

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

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

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

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

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

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

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

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