Cara membuat Daftar baru di Jawa


762

Kami membuat Setsebagai:

Set myset = new HashSet()

Bagaimana cara membuat Listdi Java?


1
Di javadoc untuk Daftar. "Semua Kelas Pelaksana Yang Diketahui: AbstractList, AbstractSequentialList, ArrayList, AttributeList, CopyOnWriteArrayList, LinkedList, Daftar Peran, PeranUnresolvedList, Stack, Vector"
KitsuneYMG

121
Pertanyaan ini adalah salah satu hit google teratas untuk "java create list" dan ia memiliki serangkaian jawaban yang sangat membantu, jadi sepertinya pertanyaan yang cukup masuk akal bagi saya :-)
JosephH

52
Ini pertanyaan yang bagus dengan jawaban yang bagus. Salah satu tujuan dari Stack Overflow adalah untuk membuat semacam jawaban kanonik untuk pertanyaan pemrograman, setidaknya menurut pendiri situs. Jadi, cobalah untuk menghindari memberi suara rendah pada posting semacam ini di masa depan, jika Anda dapat menahan godaan.
eggonlegs

Jawaban:


977
List myList = new ArrayList();

atau dengan obat generik ( Java 7 atau lebih baru)

List<MyType> myList = new ArrayList<>();

atau dengan obat generik (Versi java lama)

List<MyType> myList = new ArrayList<MyType>();

68
Perhatikan bahwa ArrayList bukan satu-satunya jenis Daftar - dan, mengenai pertanyaan, HashSet bukan satu-satunya jenis Set.
langsing

17
Saya terkejut bahwa tidak ada yang menyebutkan bahwa Anda dapat mencari antarmuka daftar dalam dokumentasi Java untuk mendapatkan daftar pasti semua kelas yang menerapkan Daftar: docs.oracle.com/javase/7/docs/api/java/util /List.html
David Mason

5
Jika Anda menggunakan IDE, Anda juga dapat secara umum melihat hierarki jenis di sana, yang mungkin lebih nyaman. Di Eclipse pintasan default adalah F4, dan di IDEA itu adalah Ctrl + H.
David Mason

1
Dari apa yang saya mengerti Anda tidak dapat menggunakan obat generik dengan ArrayList di C # MSDN
JohnOsborne

5
Argumen tipe eksplisit kedua <MyType> dapat diganti dengan hanya <> untuk Java 7 dan 8.
Jannik

469

Selain itu, jika Anda ingin membuat daftar yang memiliki banyak hal di dalamnya (meskipun ukurannya akan diperbaiki):

List<String> messages = Arrays.asList("Hello", "World!", "How", "Are", "You");

15
Peringatannya adalah bahwa daftar jenis ini (yang dikembalikan oleh asList ()) tidak dapat diubah.
Avrom

70
@ Avron - salah: itu hanya ukuran tetap: Anda tidak dapat mengubah ukuran, tetapi Anda dapat mengubah konten (peringatan dari peringatan?)
user85421

Luar biasa. Terima kasih sudah singkat.
R Claven

1
jika hanya ada satu hal dalam daftar, saya menggunakan Collections.singletonList () alih-alih Arrays.asList (). (Tapi, saya kira, saya tidak tahu mengapa.)
MikeB 9'15

@ MikeB jika Anda tidak tahu mengapa tetap berpegang pada array.aslist
bharal

183

Biarkan saya meringkas dan menambahkan sesuatu:

JDK

1. new ArrayList<String>();
2. Arrays.asList("A", "B", "C")

Jambu biji

1. Lists.newArrayList("Mike", "John", "Lesly");
2. Lists.asList("A","B", new String [] {"C", "D"});

Daftar Abadi

1. Collections.unmodifiableList(new ArrayList<String>(Arrays.asList("A","B")));
2. ImmutableList.builder()                                      // Guava
            .add("A")
            .add("B").build();
3. ImmutableList.of("A", "B");                                  // Guava
4. ImmutableList.copyOf(Lists.newArrayList("A", "B", "C"));     // Guava

Kosongkan Daftar abadi

1. Collections.emptyList();
2. Collections.EMPTY_LIST;

Daftar Karakter

1. Lists.charactersOf("String")                                 // Guava
2. Lists.newArrayList(Splitter.fixedLength(1).split("String"))  // Guava

Daftar Integer

Ints.asList(1,2,3);                                             // Guava

Ints.asListtidak membuat daftar tetap, tetapi daftar ukuran tetap didukung oleh array int yang diberikan (yaitu mendukung List.set(int, Object)). Contoh kedua "Daftar Karakter yang Tidak Berubah" juga tidak berubah (saya akan menghapus baris itu).
Xaerxess

9
Tidak menggunakan obat generik merupakan contoh yang benar-benar "baik" untuk pengembang mana pun yang akan membaca ini.
Natix

60

Di Jawa 8

Untuk membuat daftar ukuran tetap yang tidak kosong (operasi seperti menambah, menghapus, dll., Tidak didukung):

List<Integer> list = Arrays.asList(1, 2); // but, list.set(...) is supported

Untuk membuat daftar mutable yang tidak kosong:

List<Integer> list = new ArrayList<>(Arrays.asList(3, 4));

Di Jawa 9

Menggunakan List.of(...)metode pabrik statis baru :

List<Integer> immutableList = List.of(1, 2);

List<Integer> mutableList = new ArrayList<>(List.of(3, 4));

Di Jawa 10

Menggunakan Inferensi Tipe Variabel Lokal :

var list1 = List.of(1, 2);

var list2 = new ArrayList<>(List.of(3, 4));

var list3 = new ArrayList<String>();

Dan ikuti praktik terbaik ...

Jangan gunakan jenis mentah

Sejak Java 5, obat generik telah menjadi bagian dari bahasa - Anda harus menggunakannya:

List<String> list = new ArrayList<>(); // Good, List of String

List list = new ArrayList(); // Bad, don't do that!

Program untuk antarmuka

Misalnya, programkan ke Listantarmuka:

List<Double> list = new ArrayList<>();

Dari pada:

ArrayList<Double> list = new ArrayList<>(); // This is a bad idea!

1
Hai, dapatkah Anda menyarankan di mana saya dapat mempelajari perbedaan-perbedaan ini dan evolusi Jawa? Tampaknya sangat menarik!
shiv

31

Pertama baca ini , lalu baca ini dan ini . 9 kali dari 10 Anda akan menggunakan salah satu dari dua implementasi itu.

Bahkan, baca saja kerangka kerja Sun's Guide to the Collections .


11
Saya bahkan akan menambahkan "8 kali dari 10" Anda akan menggunakan ArrayList, hanya karena itu tidak masalah dalam 9,9 kali dari 10.
Joachim Sauer

1
LinkedList semantik sesuai ketika Anda hanya benar-benar peduli tentang tujuannya.
Adam Jaskiewicz

LinkedLists sangat baik jika Anda hanya akan mengulanginya. Bagi saya, sepertinya daftar yang terhubung lebih elegan, tapi mungkin itu hanya karena saya telah belajar bahasa sebelum Java.
KarlP

@Karlp Setuju. Saya akan mengatakan itu sekitar 50/50 sebagian besar waktu antara ArrayList dan LinkedList, dan jawabannya tidak selalu tentang kompleksitas operasi; lebih sering itu yang terasa tepat untuk masalah yang dihadapi.
Adam Jaskiewicz

1
Saya hampir selalu digunakan ArrayList. Jika saya hanya bekerja dengan ujung daftar, itu adalah deque (atau antrian) dan saya menggunakan ArrayDequeimplementasinya. Alasannya adalah bahwa meskipun implementasi berbasis array mungkin membuang beberapa memori pada slot kosong (ketika saya tidak dapat memprediksi kapasitas yang diperlukan), untuk koleksi kecil ini sebanding dengan overhead semua contoh node dalam daftar tertaut ( atau deque). Dan sebagai imbalannya, saya mendapatkan akses acak. Apa manfaat unik yang LinkedListdiberikan?
erickson

21
//simple example creating a list form a string array

String[] myStrings = new String[] {"Elem1","Elem2","Elem3","Elem4","Elem5"};

List mylist = Arrays.asList(myStrings );

//getting an iterator object to browse list items

Iterator itr= mylist.iterator();

System.out.println("Displaying List Elements,");

while(itr.hasNext())

  System.out.println(itr.next());

21

Karena Java 7 Anda memiliki tipe inferensi untuk pembuatan instance generik , jadi tidak perlu menduplikasi parameter generik di sisi kanan tugas:

List<String> list = new ArrayList<>();

Daftar ukuran tetap dapat didefinisikan sebagai:

List<String> list = Arrays.asList("foo", "bar");

Untuk daftar abadi Anda dapat menggunakan perpustakaan Guava :

List<String> list = ImmutableList.of("foo", "bar");

Saya punya pertanyaan tentang daftar deklarasi ini <String> list = Arrays.asList ("foo", "bar"); Saya bertanya-tanya apakah daftar dalam deklarasi adalah objek?

20

Daftar hanyalah antarmuka seperti Set .

Seperti HashSet adalah implementasi dari Set yang memiliki properti tertentu dalam hal menambah / mencari / menghapus kinerja, ArrayList adalah implementasi telanjang dari Daftar.

Jika Anda melihat dokumentasi untuk antarmuka masing-masing, Anda akan menemukan "Semua Kelas Implementasi yang Diketahui" dan Anda dapat memutuskan mana yang lebih cocok untuk kebutuhan Anda.

Kemungkinannya adalah ArrayList .


18

Listadalah antarmuka seperti Setdan memiliki ArrayListdan LinkedListsebagai implementasi tujuan umum .

Kami dapat membuat Daftar sebagai:

 List<String> arrayList = new ArrayList<>();
 List<String> linkedList = new LinkedList<>(); 

Kami juga dapat membuat daftar ukuran tetap sebagai:

List<String> list = Arrays.asList("A", "B", "C");

Kami hampir selalu menggunakan ArrayListmenentang LinkedListimplementasi:

  1. LinkedList menggunakan banyak ruang untuk objek dan berkinerja buruk ketika kita memiliki banyak elemen.
  2. Operasi yang diindeks dalam LinkedListmembutuhkan O (n) waktu dibandingkan dengan O (1) pada ArrayList.
  3. Periksa tautan ini untuk informasi lebih lanjut.

Daftar yang dibuat oleh di Arrays.asListatas tidak dapat dimodifikasi secara struktural tetapi elemen-elemennya masih dapat dimodifikasi.

Java 8

Sesuai dok , metode ini Collections.unmodifiableListmengembalikan tampilan daftar yang ditentukan yang tidak dapat dimodifikasi. Kita bisa mendapatkannya seperti:

Collections.unmodifiableList(Arrays.asList("A", "B", "C"));

Jawa 9

Jika kita menggunakan Java 9 maka:

List<String> list = List.of("A", "B");

Java 10

Dalam kasus kita berada di Jawa 10 maka metode Collectors.unmodifiableListakan mengembalikan sebuah instance dari daftar yang benar-benar unmodifiable diperkenalkan di Jawa 9. Periksa ini jawaban untuk info lebih lanjut tentang perbedaan dalam Collections.unmodifiableList vs Collectors.unmodifiableListdi Jawa 10 .


9

Terkadang - tetapi jarang - bukan ArrayList baru, Anda mungkin menginginkan LinkedList baru. Mulailah dengan ArrayList dan jika Anda memiliki masalah kinerja dan bukti bahwa daftar itu adalah masalahnya, dan banyak menambah dan menghapus daftar itu - lalu - bukan sebelum - beralih ke LinkedList dan lihat apakah semuanya membaik. Tapi di main, tetap dengan ArrayList dan semua akan baik-baik saja.


9
List list = new ArrayList();

Atau dengan obat generik

List<String> list = new ArrayList<String>();

Anda dapat, tentu saja, mengganti string dengan semua jenis variabel, seperti Integer, juga.


7

Satu contoh:

List somelist = new ArrayList();

Anda dapat melihat javadoc untuk Daftar dan menemukan semua kelas implementasi yang dikenal dari Listantarmuka yang disertakan dengan java api.


7

Menggunakan Google Collections , Anda dapat menggunakan metode berikut di kelas Daftar

import com.google.common.collect.Lists;

// ...

List<String> strings = Lists.newArrayList();

List<Integer> integers = Lists.newLinkedList();

Ada kelebihan untuk inisialisasi varargs dan inisialisasi dari Iterable<T>.

Keuntungan dari metode ini adalah Anda tidak perlu menentukan parameter generik secara eksplisit seperti yang Anda lakukan dengan konstruktor - kompiler akan mengambilnya dari jenis variabel.


6
List<Object> nameOfList = new ArrayList<Object>();

Anda perlu mengimpor Listdan ArrayList.


6

Lebih banyak opsi untuk melakukan hal yang sama dengan Java 8, tidak lebih baik, tidak lebih buruk, hanya berbeda dan jika Anda ingin melakukan beberapa pekerjaan tambahan dengan daftar, Streams akan memberi Anda lebih banyak alternatif (filter, peta, kurangi, dll.)

List<String> listA = Stream.of("a", "B", "C").collect(Collectors.toList());
List<Integer> listB = IntStream.range(10, 20).boxed().collect(Collectors.toList());
List<Double> listC = DoubleStream.generate(() -> { return new Random().nextDouble(); }).limit(10).boxed().collect(Collectors.toList());
LinkedList<Integer> listD = Stream.iterate(0, x -> x++).limit(10).collect(Collectors.toCollection(LinkedList::new));

6

Dengan Java 9, Anda dapat melakukan hal berikut untuk membuat yang tidak berubah List :

List<Integer> immutableList = List.of(1, 2, 3, 4, 5);

List<Integer> mutableList = new ArrayList<>(immutableList);

6

Sebagai opsi, Anda dapat menggunakan inisialisasi penjepit ganda di sini:

List<String> list = new ArrayList<String>(){
  {
   add("a");
   add("b");
  }
};

2
Ini operasi yang mahal. Anda sedang membuat subclass anonim dari ArrayList di sini.
Vikram Bodicherla

@ VikramBodicherla saya setuju. Lebih lanjut tentang sintaksis gula di sini.
angry_gopher


5
List arrList = new ArrayList();

Lebih baik Anda menggunakan obat generik seperti yang disarankan di bawah ini:

List<String> arrList = new ArrayList<String>();

arrList.add("one");

Jika Anda menggunakan LinkedList.

List<String> lnkList = new LinkedList<String>();

4

Menggunakan Eclipse Collections Anda dapat membuat Daftar seperti ini:

List<String> list1 = Lists.mutable.empty();
List<String> list2 = Lists.mutable.of("One", "Two", "Three");

Jika Anda ingin daftar abadi:

ImmutableList<String> list3 = Lists.immutable.empty();
ImmutableList<String> list4 = Lists.immutable.of("One", "Two", "Three");

Anda dapat menghindari tinju otomatis dengan menggunakan daftar primitif. Inilah cara Anda membuat daftar int:

MutableIntList list5 = IntLists.mutable.empty();
MutableIntList list6 = IntLists.mutable.of(1, 2, 3);

ImmutableIntList list7 = IntLists.immutable.empty();
ImmutableIntList list8 = IntLists.immutable.of(1, 2, 3);

Ada varian untuk semua 8 primitif.

MutableLongList longList       = LongLists.mutable.of(1L, 2L, 3L);
MutableCharList charList       = CharLists.mutable.of('a', 'b', 'c');
MutableShortList shortList     = ShortLists.mutable.of((short) 1, (short) 2, (short) 3);
MutableByteList byteList       = ByteLists.mutable.of((byte) 1, (byte) 2, (byte) 3);
MutableBooleanList booleanList = BooleanLists.mutable.of(true, false);
MutableFloatList floatList     = FloatLists.mutable.of(1.0f, 2.0f, 3.0f);
MutableDoubleList doubleList   = DoubleLists.mutable.of(1.0, 2.0, 3.0);

Catatan: Saya pengendara untuk Eclipse Collections.


4

Berikut ini adalah beberapa cara Anda dapat membuat daftar.

  • Ini akan membuat daftar dengan ukuran tetap, menambahkan / menghapus elemen tidak mungkin, itu akan melempar java.lang.UnsupportedOperationExceptionjika Anda mencoba melakukannya.

    List<String> fixedSizeList = Arrays.asList(new String[] {"Male", "Female"});


  • Versi berikut adalah daftar sederhana di mana Anda dapat menambah / menghapus sejumlah elemen.

    List<String> list = new ArrayList<>();


  • Ini adalah cara membuat LinkedListdi java, Jika Anda perlu sering melakukan penyisipan / penghapusan elemen pada daftar, Anda harus menggunakan LinkedListalih-alihArrayList

    List<String> linkedList = new LinkedList<>();

1
Anda bisa menggunakannya Arrays.asList("Male", "Female").
Johny

3

Coba ini:

List<String> messages = Arrays.asList("bla1", "bla2", "bla3");

Atau:

List<String> list1 = Lists.mutable.empty(); // Empty
List<String> list2 = Lists.mutable.of("One", "Two", "Three");

2

Jika Anda membutuhkan daftar yang bisa diubah-ubah dan serial dengan satu entitas, Anda dapat menggunakan:

List<String> singList = Collections.singletonList("stackoverlow");

2

Seperti deklarasi daftar array di java adalah seperti

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable  

Ada banyak cara Anda dapat membuat dan menginisialisasi daftar array di java.

 1) List list = new ArrayList();

 2) List<type> myList = new ArrayList<>();

 3) List<type> myList = new ArrayList<type>();

 4) Using Utility class

    List<Integer> list = Arrays.asList(8, 4);
    Collections.unmodifiableList(Arrays.asList("a", "b", "c"));

 5) Using static factory method

    List<Integer> immutableList = List.of(1, 2);


 6) Creation and initializing at a time

    List<String> fixedSizeList = Arrays.asList(new String[] {"Male", "Female"});



 Again you can create different types of list. All has their own characteristics

 List a = new ArrayList();
 List b = new LinkedList();
 List c = new Vector(); 
 List d = new Stack(); 
 List e = new CopyOnWriteArrayList();
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.