Cara membuat Daftar baru di Jawa

Kami membuat Setsebagai:

Set myset = new HashSet()

Bagaimana cara membuat Listdi Java?

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

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

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

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!

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 .

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

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

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 .

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 .

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.

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.

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.

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.

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

Anda perlu mengimpor Listdan ArrayList.

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

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

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

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

Ada banyak cara untuk membuat Set dan Daftar. HashSet dan ArrayList hanyalah dua contoh. Ini juga cukup umum untuk menggunakan obat generik dengan koleksi saat ini. Saya sarankan Anda melihat apa itu

Ini adalah pengantar yang bagus untuk koleksi builtin java. http://java.sun.com/javase/6/docs/technotes/guides/collections/overview.html

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

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.

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

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

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

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

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