Kami membuat Set
sebagai:
Set myset = new HashSet()
Bagaimana kita membuat Daftar
di Jawa?
List myList = new ArrayList();
atau dengan obat generik (Jawa 7 atau yang lebih baru)
List<MyType> myList = new ArrayList<>();
atau dengan obat generik (Old versi jawa)
List<MyType> myList = new ArrayList<MyType>();
Selain itu, jika anda ingin membuat daftar yang memiliki hal-hal yang di dalamnya (meskipun itu akan menjadi ukuran tetap):
List<String> messages = Arrays.asList("Hello", "World!", "How", "Are", "You");
Mari saya meringkas dan menambahkan sesuatu:
1. new ArrayList<String>();
2. Arrays.asList("A", "B", "C")
1. Lists.newArrayList("Mike", "John", "Lesly");
2. Lists.asList("A","B", new String [] {"C", "D"});
Berubah Daftar
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
Kosong berubah Daftar
1. Collections.emptyList();
2. Collections.EMPTY_LIST;
Daftar Karakter
1. Lists.charactersOf("String") // Guava
2. Lists.newArrayList(Splitter.fixedLength(1).split("String")) // Guava
Daftar bilangan Bulat
Ints.asList(1,2,3); // Guava
Untuk membuat non-kosong daftar ukuran tetap (operasi seperti menambah, menghapus, dll., tidak didukung):
List<Integer> list = Arrays.asList(1, 2); // but, list.set(...) is supported
Untuk membuat non-kosong bisa berubah daftar:
List<Integer> list = new ArrayList<>(Arrays.asList(3, 4));
Menggunakan baru klik disini.dari(...)
statis pabrik metode:
List<Integer> immutableList = List.of(1, 2);
List<Integer> mutableList = new ArrayList<>(List.of(3, 4));
Menggunakan Variabel Lokal Type Inference:
var list1 = List.of(1, 2);
var list2 = new ArrayList<>(List.of(3, 4));
var list3 = new ArrayList<String>();
Dan mengikuti praktek-praktek terbaik...
Sejak Java 5, obat generik telah menjadi bagian dari bahasa - anda harus menggunakan mereka:
List<String> list = new ArrayList<>(); // Good, List of String
List list = new ArrayList(); // Bad, don't do that!
Misalnya, program untuk Daftar
interface:
List<Double> list = new ArrayList<>();
Bukannya:
ArrayList<Double> list = new ArrayList<>(); // This is a bad idea!
Pertama baca ini, kemudian membaca ini dan ini. 9 kali dari 10, anda'll menggunakan salah satu dari dua implementasi.
Pada kenyataannya, hanya membaca Sun's Panduan untuk Koleksi framework.
Sejak Java 7 yang anda miliki type inference untuk generic contoh penciptaan, sehingga tidak perlu untuk menduplikasi generik parameter pada sisi kanan dari tugas:
List<String> list = new ArrayList<>();
Tetap-daftar ukuran dapat didefinisikan sebagai:
List<String> list = Arrays.asList("foo", "bar");
Untuk berubah daftar anda dapat menggunakan Jambu perpustakaan:
List<String> list = ImmutableList.of("foo", "bar");
//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());
List hanya sebuah interface hanya sebagai Set.
Seperti HashSet merupakan implementasi dari sebuah Set yang memiliki sifat-sifat tertentu dalam hal add / lookup / menghapus kinerja, ArrayList adalah telanjang implementasi dari Daftar.
Jika anda telah melihat dokumentasi untuk masing-masing interface anda akan menemukan "Semua yang Dikenal Melaksanakan Kelas" dan anda dapat memutuskan mana yang lebih cocok untuk kebutuhan anda.
Kemungkinannya adalah bahwa hal itu's ArrayList.
Daftar
adalah sebuah antarmuka seperti Set
dan ArrayList
dan LinkedList
sebagai tujuan umum penerapan.
Kita dapat membuat Daftar seperti:
List<String> arrayList = new ArrayList<>();
List<String> linkedList = new LinkedList<>();
Kita juga dapat membuat fixed-size daftar sebagai:
List<String> list = Arrays.asList("A", "B", "C");
Kita akan hampir selalu menggunakan ArrayList
lawan LinkedList
pelaksanaan:
LinkedList
menggunakan banyak ruang untuk benda dan berkinerja buruk ketika kita memiliki banyak elemen.LinkedList
membutuhkan O(n) kali dibandingkan dengan O(1) dalam ArrayList
.Daftar yang dibuat oleh Array.sebagai daftar
di atas tidak dapat diubah secara struktural tetapi unsur-unsurnya masih bisa dimodifikasi.
Sebagai per doc, metode Koleksi.unmodifiableList
kembali unmodifiable lihat dari daftar yang ditentukan. Kita bisa mendapatkan hal seperti:
Collections.unmodifiableList(Arrays.asList("A", "B", "C"));
Dalam hal ini kita menggunakan Jawa 9 maka:
List<String> list = List.of("A", "B");
Dalam kasus kita di Jawa 10 maka metode Kolektor.unmodifiableList
akan kembali contoh yang benar-benar unmodifiable daftar diperkenalkan di pulau Jawa 9. Check this jawaban untuk info lebih lanjut tentang perbedaan Koleksi.unmodifiableList
vs Kolektor.unmodifiableList
di Jawa 10.
Kadang - tetapi hanya jarang - bukan new ArrayList, anda mungkin ingin yang baru LinkedList. Mulai dengan ArrayList dan jika anda memiliki masalah kinerja dan bukti bahwa daftar masalah, dan banyak menambah dan menghapus ke dalam daftar itu - kemudian - tidak sebelum beralih ke LinkedList dan melihat apakah hal-hal yang meningkatkan. Tapi, tetap dengan ArrayList dan semua akan baik-baik saja.
Menggunakan Google Koleksi, anda bisa gunakan metode berikut dalam Lists kelas
import com.google.common.collect.Lists;
// ...
List<String> strings = Lists.newArrayList();
List<Integer> integers = Lists.newLinkedList();
Ada overload untuk varargs inisialisasi dan inisialisasi dari sebuah Iterable<T>
.
Keuntungan dari metode ini adalah bahwa anda don't perlu menentukan parameter generik secara eksplisit seperti yang anda lakukan dengan konstruktor - compiler akan menyimpulkan dari jenis variabel.
Sebagai pilihan, anda dapat menggunakan double brace inisialisasi berikut:
List<String> list = new ArrayList<String>(){
{
add("a");
add("b");
}
};
Ada banyak cara untuk membuat Set dan Daftar. HashSet dan ArrayList adalah hanya dua contoh. Hal ini juga cukup umum untuk menggunakan obat generik dengan koleksi hari ini. Saya sarankan anda melihat pada apa yang mereka
Ini adalah pengenalan yang baik untuk jawa's builtin koleksi. 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");
Memetikan anda gunakan LinkedList.
List<String> lnkList = new LinkedList<String>();
Lebih banyak pilihan untuk melakukan hal yang sama dengan Java 8, tidak baik, tidak buruk, hanya berbeda dan jika anda ingin melakukan beberapa pekerjaan tambahan dengan daftar, Sungai akan memberikan anda lebih banyak alternatif (filter, peta, mengurangi, 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));
Berikut adalah beberapa cara anda dapat membuat daftar.
jawa.lang.UnsupportedOperationException
jika anda mencoba untuk melakukannya.Daftar
Daftar
LinkedList
di jawa, Jika perlu anda lakukan sering penyisipan/penghapusan elemen pada daftar, anda harus menggunakan LinkedList
bukan ArrayList
Daftar