А Collection- іноді називається контейнером - це просто об'єкт, який групує кілька елементів в одну одиницю. Collections використовуються для зберігання, пошуку, маніпулювання та передачі сукупних даних. Рамка колекцій W - це єдина архітектура для представлення та маніпулювання колекціями.
HashMap JDK1.2І Hashtable JDK1.0, і використовується для представлення групи об'єктів, які представлені в <Key, Value>парі. Кожна <Key, Value>пара називається Entryоб'єктом. Збірник записів посилається на об'єкт HashMapі Hashtable. Ключі в колекції повинні бути унікальними або відмінними. [як вони використовуються для отримання відображеного значення певного ключа. значення в колекції можна дублювати.]
« Член Рамкового рівня, Спадщини та Колекції
Hashtable - це введений у спадщину клас JDK1.0, який є підкласом класу Словник. Від JDK1.2Hashtable реінжинірований для реалізації інтерфейсу Map, щоб зробити членом колекції рамки. HashMap є членом Java Collection Framework з самого початку її впровадження в JDK1.2. HashMap - це підклас класу 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 { ... }
« Початкова потужність і коефіцієнт навантаження
Ємність - це кількість відро в хеш-таблиці, а початкова ємність - просто ємність у момент створення хеш-таблиці. Зауважте, що хеш-таблиця відкрита: у випадку " hashcollision" одного відра зберігає кілька записів, які необхідно шукати послідовно. Коефіцієнт навантаження - це міра того, наскільки дозволено отримати хеш-таблицю до автоматичного збільшення її ємності.
HashMap створює порожню хеш-таблицю з початковою ємністю за замовчуванням (16) та коефіцієнтом навантаження за замовчуванням (0,75). Де, як Hashtable будує порожній хешбел із початковою ємністю за замовчуванням (11) та коефіцієнтом завантаження / коефіцієнтом заповнення (0,75).
« Структурна модифікація на випадок зіткнення хешу
HashMap, Hashtableу випадку зіткнення хешу вони зберігають записи карти у пов'язаних списках. З Java8,HashMap якщо хеш-відро зростає за певний поріг, з цього відра вимкнетьсяlinked list of entries to a balanced tree . які покращують найгірші показники від O (n) до O (log n). Під час перетворення списку у двійкове дерево, хеш-код використовується як змінна гілка. Якщо в одному відрі є два різних хеш-коди, один вважається більшим і йде праворуч від дерева, а інший - зліва. Але коли обидва хеш-коди рівні, HashMapпередбачається, що ключі порівнянні, і порівнює ключ для визначення напрямку, щоб можна було підтримувати певний порядок. Це хороша практика зробити ключі HashMap порівнянними . Додавання записів, якщо розмір відра досягаєTREEIFY_THRESHOLD = 8перетворити зв'язаний список записів у збалансоване дерево, при видаленні записів менше TREEIFY_THRESHOLD і щонайменше UNTREEIFY_THRESHOLD = 6поверне збалансоване дерево у пов'язаний список записів. Java 8 SRC , стекпост
« Ітерація перегляду колекції, Fail-Fast і Fail-Safe
+--------------------+-----------+-------------+
| | Iterator | Enumeration |
+--------------------+-----------+-------------+
| Hashtable | fail-fast | safe |
+--------------------+-----------+-------------+
| HashMap | fail-fast | fail-fast |
+--------------------+-----------+-------------+
| ConcurrentHashMap | safe | safe |
+--------------------+-----------+-------------+
Iteratorє невдалим характером. тобто він кидає ConcurrentModificationException, якщо колекцію модифікують під час ітерації, відмінного від власного методу delete (). Там, де Enumerationце безпечно відмови. Він не кидає жодних винятків, якщо колекція модифікується під час ітерації.
Згідно з Java API Docs, Iterator завжди перевага перед перерахуванням.
ПРИМІТКА . Функціонал інтерфейсу перерахування дублюється інтерфейсом Iterator. Крім того, Iterator додає необов'язкову операцію видалення та має більш короткі назви методів. Новим реалізаціям слід розглянути можливість використання Iterator у перевазі «Перерахування».
В Java 5 представлений ConcurrentMap Interface : ConcurrentHashMap- високо одночасне, високоефективне ConcurrentMapреалізація, підкріплене хеш-таблицею. Ця реалізація ніколи не блокується під час пошуку і дозволяє клієнту вибрати рівень одночасності оновлень. Він призначений як заміна заміни для Hashtable: окрім впровадження ConcurrentMap, він підтримує всі властивості "спадщини" Hashtable.
Кожне HashMapEntryзначення s є непостійним, завдяки чому забезпечується тонкодисперсна зернистість для заявлених модифікацій та наступних зчитувань; кожне прочитане відображає останнє завершене оновлення
Ітератори та перерахування є безпечними для відмов - відображають стан у певний момент з моменту створення ітератора / перерахування; це дозволяє одночасно читати та модифікувати ціною зниженої послідовності. Вони не кидають ConcurrentModificationException. Однак ітератори призначені для використання лише однією ниткою за один раз.
Як Hashtableі на відміну від HashMapцього, цей клас не дозволяє використовувати null як ключ або значення.
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();
}
}
« Нульові ключі та нульові значення
HashMapдозволяє максимально один нульовий ключ і будь-яку кількість нульових значень. Де як Hashtableне дозволяє навіть один нульовий ключ і нульове значення, якщо ключ або значення null, то він кидає NullPointerException. Приклад
« Синхронізована, безпечна для потоків
Hashtableвнутрішньо синхронізований. Тому використовувати його Hashtableв багатопотокових програмах дуже безпечно . Де як HashMapвнутрішньо не синхронізовано. Тому використання HashMapв багатопотокових програмах без зовнішньої синхронізації не є безпечним . Ви можете зовнішньо синхронізувати HashMapза допомогою Collections.synchronizedMap()методу.
« Виступ
Як Hashtableце внутрішньо синхронізовано, це робить Hashtableтрохи повільніше, ніж HashMap.
@Подивитися
