В чем разница между HashMap
и Hashtable
в Java?
Что более эффективно для непоточных приложений?
Существует несколько различий между HashMap
и Hashtable
в Java:
Hashtable
синхронизируется, а HashMap
- нет. Это делает HashMap
лучше для не-потоковых приложений, поскольку несинхронизированные объекты обычно работают лучше, чем синхронизированные.
Hashtable
не разрешает null
ключи или значения. HashMap
позволяет использовать один null
ключ и любое количество null
значений.
Одним из подклассов HashMap является LinkedHashMap
, поэтому в случае, если вам нужен предсказуемый порядок итераций (который по умолчанию является порядком размещения), вы можете легко заменить HashMap
для LinkedHashMap
. Это было бы не так просто, если бы вы использовали Hashtable
.
Поскольку синхронизация не является проблемой для вас, я бы рекомендовал HashMap
. Если синхронизация становится проблемой, вы также можете посмотреть ConcurrentHashMap
.
Обратите внимание, что во многих ответах говорится, что Hashtable синхронизирован. На практике это очень мало для вас покупает. Синхронизация по методам доступа/мутатора остановит одновременное добавление или удаление двух потоков из карты, но в реальном мире вам часто потребуется дополнительная синхронизация.
Очень распространенная идиома - "проверить, затем положить" - то есть найти запись в Map
и добавить ее, если она еще не существует. Это никоим образом не является атомарной операцией, используете ли вы Hashtable
или HashMap
.
Эквивалентно синхронизированный HashMap
может быть получен с помощью:
Collections.synchronizedMap(myMap);
Но чтобы правильно реализовать эту логику, вам нужна дополнительная синхронизация формы:
synchronized(myMap) {
if (!myMap.containsKey("tomato"))
myMap.put("tomato", "red");
}
Даже перебор записей Hashtable
(или HashMap
, полученного с помощью Collections.synchronizedMap
) не является потокобезопасным, если вы также не защитите Map
от изменения посредством дополнительной синхронизации.
Реализации интерфейса ConcurrentMap
(например, ConcurrentHashMap
) решают некоторые из этих задач, включая потокобезопасную семантику проверки-затем-действия, например:
ConcurrentMap.putIfAbsent(key, value);
Hashtable
считается устаревшим кодом. В Hashtable
ничего не может быть сделано с помощью HashMap
или дериваций HashMap
, поэтому для нового кода я не вижу никаких оснований для возврата к Hashtable
.
Этот вопрос часто задают в интервью, чтобы проверить, понимает ли кандидат правильное использование классов сбора и знает о доступных альтернативных решениях.
Примечание о некоторых важных условиях
HashMap можно синхронизировать с помощью
Map m = Collections.synchronizeMap(hashMap);
Карта предоставляет представления коллекции вместо прямой поддержки итерации через объекты Enumeration. Взгляды коллекции значительно улучшают выразительность интерфейса, как обсуждается далее в этом разделе. Карта позволяет выполнять итерацию по ключам, значениям или парам ключ-значение; Hashtable не предоставляет третий вариант. Карта обеспечивает безопасный способ для удаления записей в середине итерации; Hashtable этого не делал. Наконец, Map исправляет незначительный недостаток в интерфейсе Hashtable. Hashtable имеет метод, называемый contains, который возвращает true, если Hashtable содержит заданное значение. Учитывая его название, вы ожидаете этого метод для возврата true, если Hashtable содержал данный ключ, потому что ключ является основным механизмом доступа для Hashtable. Карта интерфейс устраняет этот источник путаницы, переименовывая метод containsValue. Кроме того, это улучшает согласованность интерфейса - containsValue parallels 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
проходит через Iterator.HashMap
работает не быстро.HashMap
наследует класс AbstractMap.Хеш-таблица
Hashtable
. Он потокобезопасен и может использоваться совместно со многими потоками.Hashtable
не допускает никакого нулевого ключа или значения.Hashtable
- это унаследованный класс.Hashtable
медленный.Hashtable
внутренне синхронизирован и не может быть несинхронизирован.Hashtable
проходит через Enumerator и Iterator.Hashtable
не работает быстро.Hashtable
наследует класс словаря.Дальнейшее чтение. Какая разница между HashMap и Hashtable в Java?
В дополнение к тому, что сказал izb, HashMap
допускает нулевые значения, тогда как Hashtable
не работает.
Также обратите внимание, что Hashtable
расширяет класс Dictionary
, который как состояние Javadocs устарел и был заменен на Map
.
Взгляните на эту диаграмму. Он обеспечивает сравнение между различными структурами данных вместе с HashMap и Hashtable. Сравнение является точным, понятным и понятным.
Hashtable
похож на HashMap
и имеет аналогичный интерфейс. Рекомендуется использовать HashMap
, если вам не нужна поддержка устаревших приложений или вам нужна синхронизация, поскольку методы Hashtables
синхронизированы. Таким образом, в вашем случае, поскольку вы не многопоточны, HashMaps
- ваш лучший выбор.
Другое ключевое различие между hashtable и hashmap заключается в том, что Iterator в HashMap работает с ошибкой, в то время как перечислитель для Hashtable не является и бросает ConcurrentModificationException, если какой-либо другой поток модифицирует структуру структурно, добавляя или удаляя любой элемент, кроме собственного Итератора remove (). Но это не гарантированное поведение и будет выполняться JVM с наилучшими усилиями ".
Мой источник: http://javarevisited.blogspot.com/2010/10/difference-between-hashmap-and.html
Помимо всех других важных аспектов, уже упомянутых здесь, API коллекций (например, интерфейс карты) постоянно изменяется, чтобы соответствовать последним и самым большим дополнениям к спецификации Java.
Например, сравните Java 5 Map iterating:
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, и по крайней мере один из потоков изменяет структуру структурно, он должен быть синхронизирован извне. Youn может обернуть несинхронизированную карту в синхронизированном режиме, используя:
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 я предполагаю, что это одно и то же, но я не совсем уверен, я не нахожу ressource, который четко заявляет об этом.
HashMap
и Hashtable
также имеют существенные алгоритмические различия. Никто не упомянул об этом раньше, поэтому я его воспитываю. HashMap
построит хеш-таблицу с мощностью двух размеров, увеличит ее динамически, так что у вас будет не более восьми элементов (коллизий) в любом ковше и будет очень хорошо перемешивать элементы для общих типов элементов. Однако реализация Hashtable
обеспечивает лучший и более тонкий контроль над хэшированием, если вы знаете, что делаете, а именно вы можете исправить размер таблицы, например, ближайшего простого числа к размеру вашего значения, и это приведет к повышению производительности, чем HashMap, т.е. к меньшему количеству конфликтов для некоторых случаев.
В отличие от очевидных различий, широко обсуждаемых в этом вопросе, я вижу Hashtable как "ручной привод", где вы лучше контролируете хеширование, а HashMap - как "автоматический привод", который обычно хорошо работает.
Hashtable синхронизируется, а HashMap - нет. Это делает Hashtable медленнее, чем Hashmap.
Для приложений, не связанных с потоком, используйте HashMap, поскольку они в остальном одинаковы с точки зрения функциональности.
Основываясь на информации здесь, я бы рекомендовал пойти с HashMap. Я думаю, что самым большим преимуществом является то, что Java не позволит вам изменить его, пока вы выполняете итерацию по нему, если вы не сделаете это через итератор.
Collection
- иногда называемая контейнером - это просто объект, который группирует несколько элементов в один блок. Collection
используется для хранения, извлечения, манипулирования и обмена совокупными данными. Рамка коллекций W представляет собой единую архитектуру для представления и управления коллекциями.
HashMap
JDK1.2
и Hashtable JDK1.0
оба используются для представления группы объектов, представленных в паре <Key, Value>
. Каждая пара <Key, Value>
называется объектом Entry
. Сбор записей относится к объекту HashMap
и Hashtable
. Ключи в коллекции должны быть уникальными или отличительными. [поскольку они используются для извлечения отображаемого значения определенного ключа. значения в коллекции могут быть дублированы.]
" Членство в суперклассе, наследие и сборник
Hashtable - это унаследованный класс, представленный в JDK1.0
, который является подклассом класса Dictionary. Из JDK1.2
Hashtable повторно спроектирован для реализации интерфейса карты, чтобы стать членом структуры коллекции. 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 { ... }
" Начальная мощность и коэффициент нагрузки
Емкость - это количество ведер в хэш-таблице, а начальная емкость - это просто емкость на момент создания хеш-таблицы. Обратите внимание, что хэш-таблица открыта: в случае " hash
collision
" в одном ведре хранится несколько записей, которые необходимо искать последовательно. Фактор нагрузки - это показатель того, насколько полная хэш-таблица может быть получена до того, как ее мощность будет автоматически увеличена.
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). При преобразовании списка в двоичное дерево hashcode используется как переменная ветвления. Если в одном ковше есть два разных хэш-кода, один считается большим и направляется справа от дерева, а другой - влево. Но когда оба хэш-кода равны, HashMap
предполагает, что ключи сопоставимы, и сравнивает ключ, чтобы определить направление, чтобы можно было поддерживать некоторый порядок. Хорошая практика - сделать ключи от HashMap
сопоставимыми. При добавлении записей, если размер ведра достигает TREEIFY_THRESHOLD = 8
конвертируйте связанный список записей в сбалансированное дерево, при удалении записей меньше TREEIFY_THRESHOLD
и самое UNTREEIFY_THRESHOLD = 6
сбалансированное дерево в связанный список записей. Java 8 SRC, stackpost
" Инициация просмотра коллекции, 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 всегда предпочитается над Enumeration.
ПРИМЕЧАНИЕ. Функциональность интерфейса Enumeration дублируется интерфейсом Iterator.Кроме того, Iterator добавляет дополнительную операцию удаления и имеет более короткие имена методов.В новых реализациях следует рассмотреть возможность использования Iterator в предпочтении Enumeration.
В Java 5 представлен интерфейс ConcurrentMap: ConcurrentHashMap
- высококонкурентная высокопроизводительная реализация ConcurrentMap
поддерживаемая хэш-таблицей. Эта реализация никогда не блокируется при выполнении повторных попыток и позволяет клиенту выбирать уровень параллелизма для обновлений. Он предназначен для замены Hashtable
: помимо реализации ConcurrentMap
он поддерживает все "унаследованные" методы, свойственные Hashtable
.
Каждое значение HashMapEntry
является летучим, обеспечивая тем самым HashMapEntry
согласованность зерен для согласованных модификаций и последующих чтений; каждое чтение отражает последнее завершенное обновление
Итераторы и перечисления являются безопасными - отражая состояние в какой-то момент с момента создания итератора/перечисления; это позволяет одновременно считывать и изменять за счет уменьшения согласованности. Они не выбрасывают 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
использовать Hashtable
в многопоточных приложениях. Если HashMap
не синхронизирован внутри страны. Поэтому небезопасно использовать HashMap
в многопоточных приложениях без внешней синхронизации. Вы можете синхронизировать HashMap
извне с помощью метода Collections.synchronizedMap()
.
" Производительность
Поскольку Hashtable
внутренне синхронизирован, это делает Hashtable
немного медленнее, чем HashMap
.
@Видеть
Различия между HashMap и Hashtable в Java:
1) Thread Safe
2) Унаследовано от
3) Нулевые ключи и нулевые значения
4) Обход
5) Fail-Fast Vs Fail-Safe
6) Производительность
7) Класс Legacy
8) Член Framework для Java
Что более эффективно для не-потоковых приложений?
Hashtable синхронизируется, а HashMap - нет.
Это делает 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
Vs O (n) в Hashtable
.
* Вышеупомянутое улучшение еще не применялось к Hashtable
, но только к HashMap
, LinkedHashMap
и ConcurrentHashMap
.
FYI, в настоящее время
TREEIFY_THRESHOLD = 8
: если ведро содержит более 8 узлов, связанный список преобразуется в сбалансированное дерево.UNTREEIFY_THRESHOLD = 6
: когда ведро становится слишком маленьким (из-за удаления или изменения размера) дерево преобразуется обратно в связанный список.Существует 5 основных различий с HashTable и HashMaps.
Мой небольшой вклад:
Первым и самым значительным отличием между
Hashtable
иHashMap
является то, чтоHashMap
не является потокобезопасным, аHashtable
является поточно-безопасной коллекцией.Вторым важным отличием между
Hashtable
иHashMap
является производительность, посколькуHashMap
не синхронизируется, он работает лучше, чемHashtable
.Третья разница в
Hashtable
vsHashMap
заключается в том, чтоHashtable
является устаревшим классом, и вы должны использоватьConcurrentHashMap
вместоHashtable
в Java.
Разница между HashMap и HashTable/HashMap vs HashTable
Синхронизация или потоковая безопасность: это самое важное различие между двумя. HashMap не синхронизирован, а не потокобезопасен. С другой стороны, HashTable является потокобезопасным и синхронизированным. Когда использовать HashMap? Ответ: если ваше приложение не требует многопоточной задачи, другими словами hashmap лучше для приложений без потоковой передачи. HashTable следует использовать в многопоточных приложениях.
Нулевые ключи и нулевые значения: Hashmap позволяет использовать один нулевой ключ и любое количество нулевых значений, в то время как Hashtable не допускает нулевые ключи и значения null в объекте HashTable.
Итерирование значений: значения объекта Hashmap повторяются с помощью итератора .HashTable - это единственный класс, отличный от вектора, который использует перечислитель для итерации значений объекта HashTable.
Неудачный итератор: итератор в Hashmap является отказоустойчивым итератором, а перечислитель для Hashtable - нет. Согласно Oracle Docs, если Hashtable структурно модифицируется в любое время после создания итератора любым способом, кроме метода удаления iterator, то итератор будет вызывать ConcurrentModification Exception. Структурная модификация означает добавление или удаление элементов из объекта Collection (здесь hashmap или hashtable). Таким образом, перечисления, возвращаемые ключами и элементами Hashtable, не ускоряются быстро. Мы уже объяснили разницу между итератором и перечислением.
Производительность: Hashmap работает намного быстрее и использует меньше памяти, чем Hashtable, поскольку прежняя несинхронизирована. Несинхронизированные объекты часто намного лучше в производительности по сравнению с синхронизированным объектом, например Hashtable, в однопоточной среде.
Суперкласс и наследие: Hashtable является подклассом класса Dictionary, который теперь устарел в Jdk 1.7, поэтому он больше не используется. Лучше синхронизировать внешнюю синхронизацию HashMap или использовать реализацию ConcurrentMap (например, ConcurrentHashMap).HashMap является подклассом класса AbstractMap. Хотя Hashtable и HashMap имеют разные суперклассы, но оба они являются реализациями абстрактных типов данных "Карта".
HashMap: это класс, доступный в пакете java.util, и он используется для хранения элемента в формате ключа и значения.
Hashtable: это унаследованный класс, который распознается в рамках коллекции.
HashTable является устаревшим классом в jdk, который больше не должен использоваться. Замените его использование ConcurrentHashMap. Если вы не нуждаетесь в безопасности потоков, используйте HashMap, который не является threadsafe, но быстрее и использует меньше памяти.
Hashtable
синхронизирован, а HashMap
- нет.HashMap
является отказоустойчивым
в то время как перечислитель для Hashtable
нет. Если вы измените карту
итерируя, вы узнаете.HashMap
разрешает нулевые значения в нем, в то время как Hashtable
нет.HashMap и HashTable
1) Hashtable и Hashmap реализуют интерфейс java.util.Map 2) 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));
}
}
HashMaps дает вам свободу синхронизации и отладки намного проще