A Collection- иногда называемый контейнером - это просто объект, который группирует несколько элементов в одну единицу. Collections используются для хранения, извлечения, манипулирования и передачи совокупных данных. Структура коллекций W представляет собой унифицированную архитектуру для представления и управления коллекциями.
И HashMap JDK1.2Hashtable JDK1.0, оба используются для представления группы объектов, представленных в <Key, Value>паре. Каждая <Key, Value>пара называется Entryобъектом. Коллекция записей ссылается на объект HashMapи Hashtable. Ключи в коллекции должны быть уникальными или отличительными. [поскольку они используются для получения сопоставленного значения определенного ключа. значения в коллекции могут быть продублированы.]
« Член суперкласса, Legacy и Collection Framework
Hashtable - это устаревший класс, представленный в JDK1.0 , который является подклассом класса Dictionary. Из JDK1.2Hashtable переработан, чтобы реализовать интерфейс Map, чтобы стать членом коллекции Framework. 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, если коллекция изменяется при выполнении итерации, отличной от собственного метода remove (). Где как Enumerationотказоустойчивый в природе. Он не выдает никаких исключений, если коллекция изменяется во время итерации.
Согласно Java API Docs, Iterator всегда предпочтительнее перечисления.
НОТА: . Функциональность интерфейса перечисления дублируется интерфейсом итератора. Кроме того, Iterator добавляет необязательную операцию удаления и имеет более короткие имена методов. Новые реализации должны рассмотреть возможность использования Iterator вместо Enumeration.
В Java 5 представлен интерфейс ConcurrentMap : 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позволяет максимум один нулевой ключ и любое количество нулевых значений. Где as Hashtableне допускает даже одного нулевого ключа и нулевого значения, если ключ или значение null, то он генерирует исключение NullPointerException.пример
« Синхронизировано, Thread Safe
Hashtableвнутренне синхронизирован. Поэтому его очень безопасно использовать Hashtableв многопоточных приложениях. Где как HashMapне внутренне синхронизировано. Поэтому использование HashMapв многопоточных приложениях без внешней синхронизации небезопасно . Вы можете внешне синхронизировать, HashMapиспользуя Collections.synchronizedMap()метод.
« Производительность
Поскольку Hashtableвнутренняя синхронизация, это делает Hashtableнемного медленнее, чем HashMap.
@Видеть
