A Collection- kadang-kadang disebut wadah - hanyalah sebuah objek yang mengelompokkan beberapa elemen menjadi satu unit. Collections digunakan untuk menyimpan, mengambil, memanipulasi, dan mengkomunikasikan data agregat. Kerangka kerja koleksi W adalah arsitektur terpadu untuk mewakili dan memanipulasi koleksi.
The HashMap JDK1.2dan Hashtable JDK1.0, keduanya digunakan untuk mewakili sekelompok objek yang diwakili <Key, Value>berpasangan. Setiap <Key, Value>pasangan disebut Entryobjek. Pengumpulan Entri disebut dengan objek HashMapdan Hashtable. Kunci dalam koleksi harus unik atau khas. [seperti yang digunakan untuk mengambil nilai yang dipetakan kunci tertentu. nilai dalam koleksi dapat diduplikasi.]
« Anggota Superclass, Legacy and Collection Framework
Hashtable adalah kelas warisan yang diperkenalkan di JDK1.0, yang merupakan subkelas dari kelas Kamus. From JDK1.2Hashtable direkayasa ulang untuk mengimplementasikan antarmuka Peta untuk membuat anggota kerangka koleksi. HashMap adalah anggota Java Collection Framework sejak awal pendahuluannya di JDK1.2. HashMap adalah subkelas dari kelas AbstractMap.
public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, Serializable { ... }
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { ... }
« Kapasitas awal dan Load factor
Kapasitas adalah jumlah ember di tabel hash, dan kapasitas awal hanyalah kapasitas pada saat tabel hash dibuat. Perhatikan bahwa tabel hash terbuka: dalam kasus " hashcollision", satu ember menyimpan banyak entri, yang harus dicari secara berurutan. Load factor adalah ukuran seberapa penuh tabel hash diizinkan dapatkan sebelum kapasitasnya meningkat secara otomatis.
HashMap membuat tabel hash kosong dengan kapasitas awal default (16) dan load factor default (0,75). Sedangkan Hashtable membangun hashtable kosong dengan kapasitas awal default (11) dan load factor / fill ratio (0,75).
« Modifikasi struktural dalam kasus tabrakan hash
HashMap, Hashtabledalam kasus tabrakan hash mereka menyimpan entri peta dalam daftar tertaut. Dari Java8 untukHashMap jika hash bucket tumbuh melampaui ambang tertentu, ember itu akan beralih dari linked list of entries to a balanced tree. yang meningkatkan kinerja kasus terburuk dari O (n) ke O (log n). Saat mengonversi daftar ke pohon biner, kode hash digunakan sebagai variabel percabangan. Jika ada dua kode hash yang berbeda dalam ember yang sama, satu dianggap lebih besar dan pergi ke kanan pohon dan yang lainnya ke kiri. Tetapi ketika kedua kode hash sama, HashMapmengasumsikan bahwa kunci sebanding, dan membandingkan kunci untuk menentukan arah sehingga beberapa urutan dapat dipertahankan. Ini adalah praktik yang baik untuk membuat kunciHashMap sebanding . Pada menambahkan entri jika ukuran ember mencapaiTREEIFY_THRESHOLD = 8konversi daftar entri yang ditautkan ke pohon seimbang, pada penghapusan entri kurang dariTREEIFY_THRESHOLD dan paling banyak UNTREEIFY_THRESHOLD = 6akan mengubah pohon seimbang ke daftar entri yang ditautkan. Java 8 SRC , stackpost
« Pengumpulan-lihat iterasi, Gagal-Cepat dan Gagal-Aman
+--------------------+-----------+-------------+
| | Iterator | Enumeration |
+--------------------+-----------+-------------+
| Hashtable | fail-fast | safe |
+--------------------+-----------+-------------+
| HashMap | fail-fast | fail-fast |
+--------------------+-----------+-------------+
| ConcurrentHashMap | safe | safe |
+--------------------+-----------+-------------+
Iteratoradalah gagal-cepat di alam. yaitu ia melempar ConcurrentModificationException jika koleksi diubah saat iterasi selain dari itu sendiri menghapus () metode. Dimana Enumerationsifatnya aman-gagal. Itu tidak membuang pengecualian jika koleksi diubah saat iterasi.
Menurut Java API Docs, Iterator selalu lebih disukai daripada Enumeration.
CATATAN: Fungsi antarmuka Enumerasi diduplikasi oleh antarmuka Iterator. Selain itu, Iterator menambahkan operasi penghapusan opsional, dan memiliki nama metode yang lebih pendek. Implementasi baru harus mempertimbangkan menggunakan Iterator dalam preferensi untuk Enumerasi.
Di Java 5 diperkenalkan Antarmuka ConcurrentMap : ConcurrentHashMap- ConcurrentMapimplementasi yang sangat konkuren, kinerja tinggi yang didukung oleh tabel hash. Implementasi ini tidak pernah memblokir ketika melakukan pengambilan dan memungkinkan klien untuk memilih tingkat konkurensi untuk pembaruan. Ini dimaksudkan sebagai pengganti drop-in untuk Hashtable: selain menerapkan ConcurrentMap, ia mendukung semua metode "warisan" yang khas Hashtable.
Setiap HashMapEntrynilai s adalah stabil sehingga memastikan konsistensi baik gandum untuk modifikasi berpendapat dan selanjutnya berbunyi; setiap pembacaan mencerminkan pembaruan yang paling baru selesai
Iterator dan Enumeration Fail Safe - mencerminkan keadaan di beberapa titik sejak penciptaan iterator / enumerasi; ini memungkinkan pembacaan simultan dan modifikasi dengan biaya pengurangan konsistensi. Mereka tidak membuang ConcurrentModificationException. Namun, iterator dirancang hanya untuk digunakan oleh satu utas pada satu waktu.
Suka Hashtabletapi tidak seperti HashMap, kelas ini tidak mengizinkan null digunakan sebagai kunci atau nilai.
public static void main(String[] args) {
//HashMap<String, Integer> hash = new HashMap<String, Integer>();
Hashtable<String, Integer> hash = new Hashtable<String, Integer>();
//ConcurrentHashMap<String, Integer> hash = new ConcurrentHashMap<>();
new Thread() {
@Override public void run() {
try {
for (int i = 10; i < 20; i++) {
sleepThread(1);
System.out.println("T1 :- Key"+i);
hash.put("Key"+i, i);
}
System.out.println( System.identityHashCode( hash ) );
} catch ( Exception e ) {
e.printStackTrace();
}
}
}.start();
new Thread() {
@Override public void run() {
try {
sleepThread(5);
// ConcurrentHashMap traverse using Iterator, Enumeration is Fail-Safe.
// Hashtable traverse using Enumeration is Fail-Safe, Iterator is Fail-Fast.
for (Enumeration<String> e = hash.keys(); e.hasMoreElements(); ) {
sleepThread(1);
System.out.println("T2 : "+ e.nextElement());
}
// HashMap traverse using Iterator, Enumeration is Fail-Fast.
/*
for (Iterator< Entry<String, Integer> > it = hash.entrySet().iterator(); it.hasNext(); ) {
sleepThread(1);
System.out.println("T2 : "+ it.next());
// ConcurrentModificationException at java.util.Hashtable$Enumerator.next
}
*/
/*
Set< Entry<String, Integer> > entrySet = hash.entrySet();
Iterator< Entry<String, Integer> > it = entrySet.iterator();
Enumeration<Entry<String, Integer>> entryEnumeration = Collections.enumeration( entrySet );
while( entryEnumeration.hasMoreElements() ) {
sleepThread(1);
Entry<String, Integer> nextElement = entryEnumeration.nextElement();
System.out.println("T2 : "+ nextElement.getKey() +" : "+ nextElement.getValue() );
//java.util.ConcurrentModificationException at java.util.HashMap$HashIterator.nextNode
// at java.util.HashMap$EntryIterator.next
// at java.util.Collections$3.nextElement
}
*/
} catch ( Exception e ) {
e.printStackTrace();
}
}
}.start();
Map<String, String> unmodifiableMap = Collections.unmodifiableMap( map );
try {
unmodifiableMap.put("key4", "unmodifiableMap");
} catch (java.lang.UnsupportedOperationException e) {
System.err.println("UnsupportedOperationException : "+ e.getMessage() );
}
}
static void sleepThread( int sec ) {
try {
Thread.sleep( 1000 * sec );
} catch (InterruptedException e) {
e.printStackTrace();
}
}
« Null Keys Dan Null Values
HashMapmemungkinkan maksimum satu kunci nol dan sejumlah nilai nol. Dimana as Hashtabletidak memungkinkan bahkan satu kunci nol dan nilai nol, jika kunci atau nilai nol maka itu melempar NullPointerException. Contoh
« Disinkronkan, Utas Aman
Hashtabledisinkronkan secara internal. Oleh karena itu, sangat aman untuk digunakan Hashtabledalam aplikasi multi-ulir. Dimana as HashMaptidak disinkronkan secara internal. Oleh karena itu, tidak aman untuk digunakan HashMapdalam aplikasi multi-ulir tanpa sinkronisasi eksternal. Anda dapat menyinkronkan secara eksternal HashMapmenggunakan Collections.synchronizedMap()metode.
« Performa
Seperti Hashtabledisinkronkan secara internal, ini membuat Hashtablesedikit lebih lambat daripada HashMap.
@Lihat
