Различия между HashMap и Hashtable?
Каковы различия между HashMap и Hashtable на яве?
Что более эффективно для непоточных приложений?
40 ответов
Есть несколько различий между HashMap а также Hashtable в Java:
Hashtableсинхронизируется, тогда какHashMapне является. Это делаетHashMapлучше для непоточных приложений, поскольку несинхронизированные объекты обычно работают лучше, чем синхронизированные.Hashtableне позволяетnullключи или значения.HashMapпозволяет одинnullключ и любое количествоnullценности.Один из подклассов HashMap
LinkedHashMapтак что в случае, если вам нужен предсказуемый порядок итераций (по умолчанию это порядок вставки), вы можете легко поменятьHashMapдляLinkedHashMap, Это было бы не так просто, если бы вы использовалиHashtable,
Поскольку синхронизация не является проблемой для вас, я бы порекомендовал HashMap, Если синхронизация становится проблемой, вы также можете посмотреть на ConcurrentHashMap,
Обратите внимание, что во многих ответах говорится, что Hashtable синхронизирован. На практике это очень мало тебя покупает. Синхронизация по методам доступа / мутатора остановит одновременное добавление или удаление двух потоков из карты, но в реальном мире вам часто потребуется дополнительная синхронизация.
Очень распространенная идиома - "проверить, затем положить" - то есть найти запись на карте и добавить ее, если она еще не существует. Это ни в коем случае не атомарная операция, используете ли вы Hashtable или HashMap.
Эквивалентно синхронизированный HashMap может быть получен с помощью:
Collections.synchronizedMap(myMap);
Но чтобы правильно реализовать эту логику, вам нужна дополнительная синхронизация формы:
synchronized(myMap) {
if (!myMap.containsKey("tomato"))
myMap.put("tomato", "red");
}
Даже перебор записей Hashtable (или HashMap, полученного Collections.synchronizedMap) не является потокобезопасным, если вы также не защитите карту от изменения посредством дополнительной синхронизации.
Реализации интерфейса ConcurrentMap (например, ConcurrentHashMap) решают некоторые из этих проблем, включая семантику проверки потока-потом-действия, такую как:
ConcurrentMap.putIfAbsent(key, value);
Hashtable считается устаревшим кодом. Там нет ничего о Hashtable это не может быть сделано с помощью HashMap или производные от HashMapпоэтому для нового кода я не вижу никакого оправдания возвращению к Hashtable,
Этот вопрос часто задают во время собеседования, чтобы проверить, понимает ли кандидат правильное использование классов сбора и знает ли он о доступных альтернативных решениях.
- Класс HashMap примерно эквивалентен классу Hashtable, за исключением того, что он не синхронизирован и допускает нулевые значения. (HashMap допускает нулевые значения как ключ и значение, тогда как Hashtable не допускает нулевые значения).
- HashMap не гарантирует, что порядок карты будет оставаться постоянным во времени.
- HashMap не синхронизирован, тогда как Hashtable синхронизирован.
- Итератор в HashMap является отказоустойчивым, а перечислитель для Hashtable - нет, и создает исключение ConcurrentModificationException, если какой-либо другой поток изменяет карту структурно, добавляя или удаляя любой элемент, кроме собственного метода удаления () Iterator. Но это не гарантированное поведение и будет выполнено JVM с максимальной отдачей.
Примечание о некоторых важных условиях
- Синхронизированный означает, что только один поток может изменить хэш-таблицу в один момент времени. По сути, это означает, что любой поток перед выполнением обновления на хеш-таблице должен будет получить блокировку объекта, в то время как другие будут ожидать снятия блокировки.
- Отказоустойчивость актуальна в контексте итераторов. Если для объекта коллекции был создан итератор, а какой-то другой поток пытается модифицировать объект коллекции "структурно", то возникает исключение одновременной модификации. Однако другие потоки могут вызывать метод "set", поскольку он не изменяет коллекцию "структурно". Однако, если до вызова "set" коллекция была изменена структурно, будет выдано "IllegalArgumentException".
- Структурная модификация означает удаление или вставку элемента, который может эффективно изменить структуру карты.
HashMap может быть синхронизирован
Map m = Collections.synchronizeMap(hashMap);
Карта обеспечивает представления коллекции вместо прямой поддержки итерации с помощью объектов перечисления. Представления коллекции значительно повышают выразительность интерфейса, как будет обсуждаться далее в этом разделе. Карта позволяет вам перебирать ключи, значения или пары ключ-значение; Hashtable не предоставляет третий вариант. Карта обеспечивает безопасный способ удаления записей в разгар итерации; Hashtable нет. Наконец, Map исправляет незначительный недостаток интерфейса Hashtable. В Hashtable есть метод с названием contains, который возвращает true, если Hashtable содержит заданное значение. Учитывая его имя, вы ожидаете, что этот метод вернет true, если Hashtable содержал данный ключ, потому что ключ является основным механизмом доступа для Hashtable. Интерфейс Map устраняет этот источник путаницы, переименовывая метод containsValue. Кроме того, это улучшает согласованность интерфейса - параллели containsValue containsKey.
HashMap: Реализация Map интерфейс, который использует хэш-коды для индексации массива.HashtableПривет, 1998 год звонил. Они хотят вернуть свои коллекции API.
Если серьезно, то лучше держаться подальше от Hashtable в целом. Для однопоточных приложений вам не нужны дополнительные издержки синхронизации. Для приложений с высокой степенью параллелизма параноидальная синхронизация может привести к голоданию, взаимоблокировкам или ненужным паузам сбора мусора. Как отметил Тим Хоулэнд, вы можете использовать ConcurrentHashMap вместо.
Имейте в виду, что HashTable был унаследованным классом до появления Java Collections Framework (JCF) и позднее был модернизирован для реализации Map интерфейс. Так было Vector а также Stack,
Поэтому всегда избегайте их в новом коде, поскольку в JCF всегда есть лучшая альтернатива, как указывали другие.
Вот шпаргалка по коллекции Java, которую вы найдете полезной. Обратите внимание, что серый блок содержит унаследованные классы HashTable,Vector и Stack.
Там уже много хорошего ответа уже выложено. Я добавляю несколько новых пунктов и обобщаю их.
HashMap а также Hashtable оба используются для хранения данных в форме ключа и значения. Оба используют технику хеширования для хранения уникальных ключей. Но есть много различий между классами HashMap и Hashtable, которые приведены ниже.
HashMap
HashMapне синхронизирован. Он не является потокобезопасным и не может быть разделен между многими потоками без надлежащего кода синхронизации.HashMapпозволяет один нулевой ключ и несколько нулевых значений.HashMapэто новый класс, представленный в JDK 1.2.HashMapэто быстро.- Мы можем сделать
HashMapкак синхронизируется с помощью вызова этого кодаMap m = Collections.synchronizedMap(HashMap); HashMapпроходит через итератор.- Итератор в
HashMapбыстро проваливается HashMapнаследует класс AbstractMap.
Хеш-таблица
Hashtableсинхронизирован. Это потокобезопасный и может быть разделен со многими потоками.Hashtableне допускает нулевой ключ или значение.Hashtableэто унаследованный класс.Hashtableмедленный.Hashtableвнутренне синхронизирован и не может быть несинхронизирован.Hashtableпроходит через перечислитель и итератор.- Перечислитель в
Hashtableне быстро провал. Hashtableнаследует словарь класса.
Дальнейшее чтение В чем разница между HashMap и Hashtable в Java?
Посмотрите на этот график. Это обеспечивает сравнение между различными структурами данных наряду с HashMap и Hashtable. Сравнение точное, понятное и простое для понимания.
В дополнение к тому, что сказал Изб, HashMap допускает нулевые значения, тогда как Hashtable не.
Также обратите внимание, что Hashtable расширяет Dictionary класс, который, как заявляют Javadocs, устарел и был заменен Map интерфейс.
Hashtable похож на HashMap и имеет аналогичный интерфейс. Рекомендуется использовать HashMap, если вам не требуется поддержка устаревших приложений или вам не нужна синхронизация, так как Hashtables методы синхронизированы. Так что в вашем случае, поскольку вы не многопоточность, HashMaps ваш лучший выбор.
Hashtable синхронизируется, а HashMap - нет. Это делает Hashtable медленнее, чем Hashmap.
Для непоточных приложений используйте HashMap, так как в остальном они одинаковы по функциональности.
Другое ключевое отличие между hashtable и hashmap заключается в том, что Iterator в HashMap является отказоустойчивым, а перечислитель для Hashtable - нет, и выдает исключение ConcurrentModificationException, если какой-либо другой поток изменяет карту структурно, добавляя или удаляя любой элемент, кроме собственного метода Iterator (). Но это не гарантированное поведение, и JVM сделает все возможное ".
Мой источник: http://javarevisited.blogspot.com/2010/10/difference-between-hashmap-and.html
Помимо всех других важных аспектов, уже упомянутых здесь, API-интерфейс Collections (например, интерфейс Map) постоянно изменяется, чтобы соответствовать "последним и лучшим" дополнениям спецификации Java.
Например, сравните итерацию Java 5 Map:
for (Elem elem : map.keys()) {
elem.doSth();
}
по сравнению со старым подходом Hashtable:
for (Enumeration en = htable.keys(); en.hasMoreElements(); ) {
Elem elem = (Elem) en.nextElement();
elem.doSth();
}
В Java 1.8 нам также обещают создавать и получать доступ к HashMaps, как в старых добрых скриптовых языках:
Map<String,Integer> map = { "orange" : 12, "apples" : 15 };
map["apples"];
Обновление: нет, они не будут приземляться в 1.8...:(
HashTable синхронизируется, если вы используете его в одном потоке, вы можете использовать HashMap, который является несинхронизированной версией. Несинхронизированные объекты часто немного более производительны. Кстати, если несколько потоков обращаются к HashMap одновременно, и хотя бы один из потоков структурно изменяет карту, она должна быть синхронизирована извне. Вы можете обернуть несинхронизированную карту в синхронизированную, используя:
Map m = Collections.synchronizedMap(new HashMap(...));HashTable может содержать ненулевой объект только в качестве ключа или значения. HashMap может содержать один нулевой ключ и нулевые значения.
Итераторы, возвращаемые Map, работают быстро, если карта структурно модифицирована в любое время после создания итератора, любым способом, кроме как через собственный метод удаления итератора, итератор выдаст
ConcurrentModificationException, Таким образом, перед одновременной модификацией итератор быстро и чисто дает сбой, вместо того, чтобы рисковать произвольным недетерминированным поведением в неопределенное время в будущем. Принимая во внимание, что перечисления, возвращаемые методами ключей и элементов Hashtable, не работают быстро.HashTable и HashMap являются членами Java Collections Framework (начиная с платформы Java 2 v1.2, HashTable был модернизирован для реализации интерфейса Map).
HashTable считается унаследованным кодом, в документации рекомендуется использовать ConcurrentHashMap вместо Hashtable, если требуется многопотоковая реализация, ориентированная на многопоточность.
HashMap не гарантирует порядок, в котором элементы возвращаются. Что касается HashTable, я думаю, что это то же самое, но я не совсем уверен, я не нахожу ресурсы, в которых это четко указано.
HashMap а также Hashtable также имеют значительные алгоритмические различия. Никто не упоминал об этом раньше, поэтому я поднимаю это. HashMap создаст хэш-таблицу со степенью двух размеров, динамически увеличит ее так, чтобы в каждом сегменте было не более восьми элементов (столкновений), и будет очень хорошо перемешивать элементы для общих типов элементов. Тем не менее Hashtable Реализация обеспечивает лучший и более точный контроль над хэшированием, если вы знаете, что делаете, а именно, вы можете фиксировать размер таблицы, используя, например, ближайшее простое число к размеру домена ваших значений, и это приведет к лучшей производительности, чем HashMap, т.е. меньше коллизий в некоторых случаях,
Помимо очевидных различий, широко обсуждаемых в этом вопросе, я рассматриваю Hashtable как автомобиль с "ручным приводом", где вы лучше контролируете хеширование, а HashMap как аналог "автоматического привода", который в целом будет работать хорошо.
Основываясь на информации здесь, я бы рекомендовал перейти с HashMap. Я думаю, что самым большим преимуществом является то, что Java не позволит вам изменять его, пока вы выполняете его итерацию, если вы не сделаете это через итератор.
Collection - иногда называемый контейнером - это просто объект, который группирует несколько элементов в одну единицу. Collection s используются для хранения, извлечения, манипулирования и передачи совокупных данных. Структура коллекций W - это унифицированная архитектура для представления и управления коллекциями.
HashMapJDK1.2 и Hashtable JDK1.0 оба используются для представления группы объектов, которые представлены в <Key, Value> пара. каждый <Key, Value> пара называется Entry объект. Коллекция записей ссылается на объект HashMap а также Hashtable, Ключи в коллекции должны быть уникальными или отличительными. [поскольку они используются для получения сопоставленного значения определенного ключа. значения в коллекции могут быть продублированы.]
" Член суперкласса, Legacy и Collection Framework
Hashtable - это устаревший класс, представленный в JDK1.0 , который является подклассом класса Dictionary. От JDK1.2 Hashtable переработан для реализации интерфейса 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). Где as 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 разрешает максимум один нулевой ключ и любое количество нулевых значений. В то время как Hashtable не допускает даже одного нулевого ключа и нулевого значения, если ключ или значение равно нулю, тогда он генерирует исключение NullPointerException. пример
" Синхронизировано, Thread Safe
Hashtable внутренне синхронизирован. Поэтому это очень безопасно для использования Hashtable в многопоточных приложениях. В то время как HashMap внутренне не синхронизирован. Таким образом, это не безопасно использовать HashMap в многопоточных приложениях без внешней синхронизации. Вы можете внешне синхронизировать HashMap с помощью Collections.synchronizedMap() метод.
" Производительность
Как Hashtable внутренне синхронизированы, это делает Hashtable немного медленнее, чем HashMap,
@Увидеть
Для многопоточных приложений вы часто можете использовать ConcurrentHashMap- это зависит от ваших требований к производительности.
1.Hashmap а также HashTable и хранить ключ и значение.
2.Hashmap может хранить один ключ как null, Hashtable не может хранить null,
3.HashMap не синхронизируется, но Hashtable синхронизирован.
4.HashMap можно синхронизировать с Collection.SyncronizedMap(map)
Map hashmap = new HashMap();
Map map = Collections.SyncronizedMap(hashmap);
Помимо уже упомянутых различий, следует отметить, что, начиная с Java 8, HashMap Динамически заменяет узлы (связанный список), используемые в каждом сегменте, на TreeNodes (красно-черное дерево), так что даже если существуют коллизии с высоким хешем, наихудший случай при поиске
O(log(n)) для HashMap Против O(n) в Hashtable,
* Вышеупомянутое улучшение не было применено к Hashtable пока, но только для HashMap, LinkedHashMap, а также ConcurrentHashMap,
К вашему сведению, в настоящее время
TREEIFY_THRESHOLD = 8: если корзина содержит более 8 узлов, связанный список преобразуется в сбалансированное дерево.UNTREEIFY_THRESHOLD = 6: когда область памяти становится слишком маленькой (из-за удаления или изменения размера), дерево преобразуется обратно в связанный список.
Есть 5 основных различий с HashTable и HashMaps.
- Карты позволяют вам перебирать и извлекать ключи, значения, а также обе пары ключ-значение, где HashTable не имеет всей этой возможности.
- В Hashtable есть функция contains(), которую очень сложно использовать. Потому что смысл содержит немного отклоняется. Значит ли это содержит ключ или содержит значение? трудно понять. То же самое в Картах у нас есть функции ContainsKey() и ContainsValue(), которые очень легко понять.
- В hashmap вы можете безопасно удалять элементы во время итерации. где это невозможно в хеш-таблицах.
- HashTables по умолчанию синхронизированы, поэтому их можно легко использовать с несколькими потоками. Где, поскольку HashMaps не синхронизируются по умолчанию, поэтому может использоваться только с одним потоком. Но вы все равно можете преобразовать HashMap в синхронизированный с помощью функции synchronizedMap(Map m) класса Collections утилит.
- HashTable не допускает нулевые ключи или нулевые значения. Где в HashMap допускается один нулевой ключ и несколько нулевых значений.
Мой маленький вклад:
Первая и самая значимая разница между
Hashtableа такжеHashMapв том, что,HashMapне является потокобезопасным в то время какHashtableэто потокобезопасная коллекция.Второе важное различие между
Hashtableа такжеHashMapэто производительность, так какHashMapне синхронизируется, это работает лучше, чемHashtable,Третье отличие на
HashtableпротивHashMapв том, чтоHashtableявляется устаревшим классом, и вы должны использоватьConcurrentHashMapна местеHashtableна Яве.
HashMap:- Это класс, доступный в пакете java.util, и он используется для хранения элемента в формате ключа и значения.
Hashtable: -Это устаревший класс, который распознается в рамках коллекции
И HashMap, и Hashtable используются для хранения данных в форме ключа и значения. Оба используют технику хеширования для хранения уникальных ключей. но есть много различий между классами HashMap и Hashtable, которые приведены ниже.
HashTable - это устаревший класс в jdk, который больше не должен использоваться. Замените его использование ConcurrentHashMap. Если вам не требуется безопасность потоков, используйте HashMap, который не является потокобезопасным, но быстрее и использует меньше памяти.
1)Hashtable синхронизируется, а hashmap - нет. 2) Другое отличие состоит в том, что итератор в HashMap является отказоустойчивым, а перечислитель для Hashtable - нет. Если вы измените карту во время итерации, вы будете знать.
3) HashMap разрешает нулевые значения в нем, а Hashtable - нет.
HashMap и HashTable
- Некоторые важные моменты о HashMap и HashTable. пожалуйста, прочитайте ниже детали.
1) Hashtable и Hashmap реализуют интерфейс java.util.Map. 2) Hashmap и Hashtable - это основанная на хэше коллекция. и работает на хеширование. так что это сходство HashMap и HashTable.
- В чем разница между HashMap и HashTable?
1) Первое отличие состоит в том, что HashMap не является потокобезопасным, в то время как HashTable является ThreadSafe.
2) HashMap лучше по производительности, потому что он не безопасен для потоков. в то время как производительность Hashtable не лучше, так как она безопасна для потоков. поэтому несколько потоков не могут получить доступ к Hashtable одновременно.
Hashtable:
Hashtable - это структура данных, которая сохраняет значения пары ключ-значение. Он не допускает null для ключей и значений. Вы получите NullPointerException если вы добавите нулевое значение. Это синхронизировано. Так что это идет с его стоимостью. Только один поток может получить доступ к HashTable в определенное время.
Пример:
import java.util.Map;
import java.util.Hashtable;
public class TestClass {
public static void main(String args[ ]) {
Map<Integer,String> states= new Hashtable<Integer,String>();
states.put(1, "INDIA");
states.put(2, "USA");
states.put(3, null); //will throw NullPointerEcxeption at runtime
System.out.println(states.get(1));
System.out.println(states.get(2));
// System.out.println(states.get(3));
}
}
HashMap:
HashMap похож на Hashtable, но он также принимает пару ключ-значение. Это позволяет null как для ключей, так и для значений. Его производительность лучше, чем лучше HashTable, потому что это так unsynchronized,
Пример:
import java.util.HashMap;
import java.util.Map;
public class TestClass {
public static void main(String args[ ]) {
Map<Integer,String> states = new HashMap<Integer,String>();
states.put(1, "INDIA");
states.put(2, "USA");
states.put(3, null); // Okay
states.put(null,"UK");
System.out.println(states.get(1));
System.out.println(states.get(2));
System.out.println(states.get(3));
}
}
Поскольку Hashtable в Java является подклассом класса Dictionary, который в настоящее время устарел из-за существования Map Interface, он больше не используется. Более того, вы не можете ничего сделать с классом, реализующим интерфейс Map, который вы можете сделать с помощью Hashtable.
Старая и классическая тема, просто хочу добавить этот полезный блог, который объясняет это:
http://blog.manishchhabra.com/2012/08/the-5-main-differences-betwen-hashmap-and-hashtable/
Блог Маниша Чхабры
5 основных отличий между HashMap и Hashtable
HashMap и Hashtable оба реализуют интерфейс java.util.Map, но есть некоторые различия, которые разработчики Java должны понимать, чтобы писать более эффективный код. Начиная с платформы Java 2 v1.2 класс Hashtable был модифицирован для реализации интерфейса Map, что сделало его членом Java Collections Framework.
Одно из основных различий между HashMap и Hashtable заключается в том, что HashMap не синхронизирован, а Hashtable синхронизирован, что означает, что Hashtable поточно-ориентирован и может использоваться несколькими потоками, но HashMap не может использоваться несколькими потоками без надлежащей синхронизации. Java 5 представила ConcurrentHashMap, который является альтернативой Hashtable и обеспечивает лучшую масштабируемость, чем Hashtable в Java. Синхронизированный означает, что только один поток может изменить хэш-таблицу в один момент времени. По сути, это означает, что любой поток перед выполнением обновления на хеш-таблице должен будет получить блокировку объекта, в то время как другие будут ожидать снятия блокировки.
Класс HashMap примерно эквивалентен классу Hashtable, за исключением того, что он допускает нулевые значения. (HashMap допускает нулевые значения как ключ и значение, тогда как Hashtable не допускает нулевые значения).
Третье существенное различие между HashMap и Hashtable заключается в том, что Iterator в HashMap является итератором, работающим без сбоев, а перечислитель для Hashtable - нет, и генерирует исключение ConcurrentModificationException, если какой-либо другой поток изменяет карту структурно, добавляя или удаляя любой элемент, кроме собственного удаления Iterator () метод. Но это не гарантированное поведение и будет выполнено JVM с максимальной отдачей. Это также важное различие между перечислением и итератором в Java.
Еще одно заметное отличие между Hashtable и HashMap состоит в том, что из-за безопасности потоков и синхронизации Hashtable намного медленнее, чем HashMap, если используется в однопоточной среде. Поэтому, если вам не нужна синхронизация и HashMap используется только одним потоком, он выполняет Hashtable на Java.
HashMap не гарантирует, что порядок карты будет оставаться постоянным во времени.
Обратите внимание, что HashMap может быть синхронизирован
Map m = Collections.synchronizedMap(hashMap);В заключение, существуют существенные различия между Hashtable и HashMap в Java, например, потокобезопасность и скорость, и основанная на том, что Hashtable используется только в том случае, если вам абсолютно необходима безопасность потоков, если вы используете Java 5, подумайте об использовании ConcurrentHashMap в Java.