Различия между HashMap и Hashtable?
1451043 просмотра
30 ответа
Каковы различия между a HashMap
и a Hashtable
в Java?
Что более эффективно для непоточных приложений?
Автор: dmanxiii Источник Размещён: 16.08.2019 10:12Ответы (30)
3577 плюса
Есть несколько различий между HashMap
и Hashtable
в Java:
Hashtable
будет синхронизировано , тогда как этоHashMap
не так. ЭтоHashMap
лучше для не поточных приложений, поскольку несинхронизированные объекты обычно работают лучше, чем синхронизированные.Hashtable
не разрешаетnull
ключи или значения.HashMap
позволяет одинnull
ключ и любое количествоnull
значений.Одним из подклассов HashMap является
LinkedHashMap
, поэтому в случае, если вам нужен предсказуемый порядок итераций (по умолчанию это порядок вставки), вы можете легко поменять формулуHashMap
на aLinkedHashMap
. Это было бы не так просто, если бы вы использовалиHashtable
.
Поскольку синхронизация не является проблемой для вас, я бы порекомендовал HashMap
. Если синхронизация становится проблемой, вы также можете посмотреть ConcurrentHashMap
.
638 плюса
Обратите внимание, что во многих ответах говорится, что 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);
Автор: serg10
Размещён: 03.09.2008 11:00
333 плюса
Hashtable
считается устаревшим кодом. Ничего в Hashtable
этом не может быть сделано с использованием HashMap
или производными HashMap
, поэтому для нового кода я не вижу никакого оправдания возвращению Hashtable
.
169 плюса
Этот вопрос часто задают на собеседовании, чтобы проверить, понимает ли кандидат правильное использование коллекционных классов и знает ли он о доступных альтернативных решениях.
- Класс 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. Также,
Автор: sravan Размещён: 04.10.2011 06:39
121 плюса
HashMap
: Реализация Map
интерфейса, использующего хэш-коды для индексации массива.
Hashtable
Привет, 1998 год звонил. Они хотят вернуть свои коллекции API.
Если серьезно, вам лучше держаться подальше от Hashtable
всего. Для однопоточных приложений вам не нужны дополнительные издержки синхронизации. Для приложений с высокой степенью одновременности параноидальная синхронизация может привести к голоданию, взаимоблокировкам или ненужным паузам сбора мусора. Как указал Тим Хоулэнд, вы можете использовать ConcurrentHashMap
вместо этого.
115 плюса
Имейте в виду, что это HashTable
был унаследованный класс до появления Java Collections Framework (JCF) и позднее был модернизирован для реализации Map
интерфейса. Так было Vector
и так Stack
.
Поэтому всегда избегайте их в новом коде, поскольку в JCF всегда есть лучшая альтернатива, как указывали другие.
Вот шпаргалка по коллекции Java, которую вы найдете полезной. Обратите внимание, что серый блок содержит унаследованные классы HashTable, Vector и Stack.
64 плюса
Там уже много хорошего ответа уже выложено. Я добавляю несколько новых пунктов и обобщаю их.
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?
Автор: roottraveller Размещён: 06.03.2017 10:0962 плюса
В дополнение к тому, что сказал izb, HashMap
допускает нулевые значения, тогда как Hashtable
нет.
Также обратите внимание, что Hashtable
расширяет Dictionary
класс, который, как состояние Javadocs , устарел и был заменен Map
интерфейсом.
54 плюса
Посмотрите на этот график. Это обеспечивает сравнение между различными структурами данных наряду с HashMap и Hashtable. Сравнение точное, понятное и простое для понимания.
Автор: Sujan Размещён: 20.11.2012 05:3546 плюса
Hashtable
похож на HashMap
и имеет аналогичный интерфейс. Рекомендуется использовать HashMap
, если вам не требуется поддержка устаревших приложений или вам не нужна синхронизация, поскольку Hashtables
методы синхронизируются. Так что в вашем случае, поскольку вы не многопоточны, HashMaps
ваш лучший выбор.
34 плюса
Другое ключевое отличие между hashtable и hashmap заключается в том, что Iterator в HashMap работает без сбоев, а перечислитель для Hashtable - нет, и генерирует исключение ConcurrentModificationException, если какой-либо другой поток изменяет карту структурно, добавляя или удаляя любой элемент, кроме собственного метода Iterator (). Но это не гарантированное поведение, и JVM сделает все возможное ».
Мой источник: http://javarevisited.blogspot.com/2010/10/difference-between-hashmap-and.html
Автор: Neerja Размещён: 08.09.2011 06:4034 плюса
Помимо всех других важных аспектов, уже упомянутых здесь, 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 ... :(
Будут ли улучшены коллекции Project Coin в JDK8?
Автор: pwes Размещён: 12.01.2012 09:1728 плюса
HashTable синхронизируется, если вы используете его в одном потоке, вы можете использовать HashMap , который является несинхронизированной версией. Несинхронизированные объекты часто немного более производительны. Кстати, если несколько потоков обращаются к HashMap одновременно, и хотя бы один из потоков структурно изменяет карту, она должна быть синхронизирована извне. Вы можете обернуть несинхронизированную карту в синхронизированную, используя:
Map m = Collections.synchronizedMap(new HashMap(...));
HashTable может содержать ненулевой объект только в качестве ключа или значения. HashMap может содержать один нулевой ключ и нулевые значения.
Итераторы, возвращаемые Map, работают быстро, если карта структурно модифицирована в любое время после создания итератора, любым способом, кроме как через собственный метод удаления итератора, итератор выдает a
ConcurrentModificationException
. Таким образом, перед одновременной модификацией итератор быстро и чисто дает сбой, вместо того, чтобы рисковать произвольным недетерминированным поведением в неопределенное время в будущем. Принимая во внимание, что перечисления, возвращаемые методами ключей и элементов Hashtable, не работают быстро.HashTable и HashMap являются членами Java Collections Framework (начиная с платформы Java 2 v1.2, HashTable был модернизирован для реализации интерфейса Map).
HashTable считается унаследованным кодом, в документации рекомендуется использовать ConcurrentHashMap вместо Hashtable, если требуется многопотоковая реализация, ориентированная на многопоточность.
HashMap не гарантирует порядок, в котором элементы возвращаются. Что касается HashTable, я думаю, что это то же самое, но я не совсем уверен, я не нахожу ресурсы, в которых это четко указано.
27 плюса
HashMap
и Hashtable
имеют значительные алгоритмические различия, а также. Никто не упоминал об этом раньше, поэтому я поднимаю это. HashMap
создаст хеш-таблицу со степенью двойки, динамически увеличит ее так, чтобы в каждом сегменте было не более восьми элементов (столкновений), и будет очень хорошо перемешивать элементы для общих типов элементов. Тем не менее, Hashtable
реализация обеспечивает лучший и более точный контроль над хэшированием, если вы знаете, что делаете, а именно, вы можете фиксировать размер таблицы, используя, например, ближайшее простое число к размеру домена ваших значений, и это приведет к лучшей производительности, чем HashMap, т.е. меньше коллизий для некоторых случаев.
Помимо очевидных различий, широко обсуждаемых в этом вопросе, я рассматриваю Hashtable как автомобиль с «ручным приводом», где вы лучше контролируете хеширование, а HashMap как аналог «автоматического привода», который в целом будет работать хорошо.
Автор: SkyWalker Размещён: 10.12.2012 08:5725 плюса
Hashtable синхронизируется, а HashMap - нет. Это делает Hashtable медленнее, чем Hashmap.
Для непоточных приложений используйте HashMap, поскольку в остальном они одинаковы по функциональности.
Автор: izb Размещён: 02.09.2008 08:2223 плюса
Основываясь на информации здесь , я бы рекомендовал перейти с HashMap. Я думаю, что самым большим преимуществом является то, что Java не позволит вам изменять его, пока вы выполняете итерацию, если вы не сделаете это через итератор.
Автор: pkaeding Размещён: 02.09.2008 08:1422 плюса
A Collection
- иногда называемый контейнером - это просто объект, который группирует несколько элементов в одну единицу. Collection
s используются для хранения, извлечения, манипулирования и передачи совокупных данных. Структура коллекций W представляет собой унифицированную архитектуру для представления и управления коллекциями.
И HashMap
JDK1.2
Hashtable JDK1.0
, оба используются для представления группы объектов, представленных в <Key, Value>
паре. Каждая <Key, Value>
пара называется Entry
объектом. Коллекция записей ссылается на объект HashMap
и Hashtable
. Ключи в коллекции должны быть уникальными или отличительными. [поскольку они используются для получения сопоставленного значения определенного ключа. значения в коллекции могут быть продублированы.]
« Член суперкласса, Legacy и Collection Framework
Hashtable - это унаследованный класс JDK1.0
, который является подклассом класса Dictionary. Из JDK1.2
Hashtable переработан, чтобы реализовать интерфейс 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 { ... }
« Начальная емкость и коэффициент загрузки
Емкость - это количество сегментов в хэш-таблице, а начальная емкость - это просто емкость на момент создания хеш-таблицы. Обратите внимание, что хеш-таблица открыта: в случае « hash
collision
» в одном сегменте хранятся несколько записей, которые необходимо искать последовательно. Коэффициент загрузки - это мера того, насколько полной хеш-таблице разрешено получать до того, как ее емкость будет автоматически увеличена.
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
позволяет максимум один нулевой ключ и любое количество нулевых значений. Где as Hashtable
не допускает даже одного нулевого ключа и нулевого значения, если ключ или значение null, то он генерирует исключение NullPointerException. пример
« Синхронизировано, Thread Safe
Hashtable
внутренне синхронизирован. Поэтому его очень безопасно использовать Hashtable
в многопоточных приложениях. Где как HashMap
не внутренне синхронизировано. Поэтому использование HashMap
в многопоточных приложениях без внешней синхронизации небезопасно . Вы можете внешне синхронизировать, HashMap
используя Collections.synchronizedMap()
метод.
« Производительность
Поскольку Hashtable
внутренняя синхронизация, это делает Hashtable
немного медленнее, чем HashMap
.
@Увидеть
- Красно-черное дерево - это своего рода самобалансирующееся дерево бинарного поиска
- Улучшение производительности для
HashMap
в Java 8
17 плюса
Для многопоточных приложений вы часто можете использовать ConcurrentHashMap - это зависит от ваших требований к производительности.
Автор: Tim Howland Размещён: 02.09.2008 10:3815 плюса
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);
Автор: Rahul Tripathi
Размещён: 27.08.2014 11:29
15 плюса
Помимо уже упомянутых различий, следует отметить, что, начиная с Java 8, HashMap
динамически заменяет узлы (связанный список), используемые в каждом сегменте, на TreeNodes (красно-черное дерево), так что, даже если существуют коллизии с высоким хешем, наихудший случай, когда поиск является
O (log (n)) для HashMap
Vs O (n) в Hashtable
.
* Вышеупомянутое улучшение не применяется к Hashtable
еще, но только HashMap
, LinkedHashMap
и ConcurrentHashMap
.
К вашему сведению, в настоящее время
TREEIFY_THRESHOLD = 8
: если корзина содержит более 8 узлов, связанный список преобразуется в сбалансированное дерево.UNTREEIFY_THRESHOLD = 6
: когда область памяти становится слишком маленькой (из-за удаления или изменения размера), дерево преобразуется обратно в связанный список.
13 плюса
Есть 5 основных различий с HashTable и HashMaps.
- Карты позволяют вам перебирать и извлекать ключи, значения, а также обе пары ключ-значение, где HashTable не имеет всей этой возможности.
- В Hashtable есть функция contains (), которую очень сложно использовать. Потому что смысл содержит немного отклоняется. Значит ли это содержит ключ или содержит значение? трудно понять. То же самое в Картах у нас есть функции ContainsKey () и ContainsValue (), которые очень легко понять.
- В hashmap вы можете безопасно удалять элементы во время итерации. где это невозможно в хеш-таблицах.
- HashTables по умолчанию синхронизированы, поэтому их можно легко использовать с несколькими потоками. Где, поскольку HashMaps не синхронизируются по умолчанию, поэтому может использоваться только с одним потоком. Но вы все равно можете конвертировать HashMap в синхронизированный с помощью функции synchronizedMap (Map m) класса Collections утилит.
- HashTable не допускает нулевые ключи или нулевые значения. Где как HashMap допускает один нулевой ключ и несколько нулевых значений.
12 плюса
Мой маленький вклад:
Автор: Shreyos Adikari Размещён: 18.03.2014 09:46
Первое и самое значительное различались
Hashtable
и вHashMap
том , что,HashMap
не поточно-то времяHashtable
является поточно-коллекция.Второе важное отличие
Hashtable
иHashMap
является производительность, так какHashMap
не синхронизируется это лучше , чемHashtable
.Третье отличие от
Hashtable
vs вHashMap
том, чтоHashtable
это устаревший класс, и вы должны использовать егоConcurrentHashMap
вместоHashtable
Java.
9 плюса
HashTable - это устаревший класс в jdk, который больше не должен использоваться. Замените его использование ConcurrentHashMap . Если вам не требуется безопасность потоков, используйте HashMap, который не является потокобезопасным, но быстрее и использует меньше памяти.
Автор: jontejj Размещён: 15.04.2013 02:499 плюса
HashMap: это класс, доступный в пакете java.util, и он используется для хранения элемента в формате ключа и значения.
Hashtable: это унаследованный класс, который распознается в рамках коллекции.
Автор: Ankit Размещён: 31.01.2013 01:418 плюса
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 одновременно.
8 плюса
Hashtable
синхронизируется, тогдаHashMap
как нет.- Другое отличие состоит в том, что итератор в методе
HashMap
отказоустойчив, а перечислительHashtable
- нет. Если вы измените карту во время итерации, вы будете знать. HashMap
разрешает нулевые значения в нем, покаHashtable
нет.
7 плюса
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));
}
}
Автор: IntelliJ Amiya
Размещён: 10.02.2015 07:44
4 плюса
HashMaps дает вам свободу синхронизации и отладки намного проще
Автор: user1506047 Размещён: 09.08.2012 12:284 плюса
HashMap
эмулируется и, следовательно, может использоваться в GWT client code
то время Hashtable
как нет.
4 плюса
Синхронизация или потокобезопасность :
Хэш-карта не синхронизирована, следовательно, она не является безопасной и не может быть разделена между несколькими потоками без надлежащего синхронизированного блока, тогда как Hashtable синхронизируется и, следовательно, является поточно-ориентированным.
Нулевые ключи и нулевые значения :
HashMap допускает один нулевой ключ и любое количество нулевых значений. Hashtable не допускает нулевые ключи или значения.
Итерация значений :
Итератор в HashMap - это отказоустойчивый итератор, а перечислитель для Hashtable - нет, и он создает исключение ConcurrentModificationException, если какой-либо другой поток изменяет карту структурно, добавляя или удаляя любой элемент, кроме собственного метода Iterator ().
Суперкласс и Наследие :
HashMap является подклассом класса AbstractMap, тогда как Hashtable является подклассом класса Dictionary.
Производительность :
Поскольку HashMap не синхронизируется, он быстрее по сравнению с Hashtable.
См. Http://modernpathshala.com/Article/1020/difference-between-hashmap-and-hashtable-in-java для примеров и вопросов интервью и викторины, связанной с коллекцией Java
Автор: amitguptageek Размещён: 05.01.2016 06:35Вопросы из категории :
- java В чем разница между int и Integer в Java и C #?
- java Как я могу определить IP моего маршрутизатора / шлюза в Java?
- java Каков наилучший способ проверки XML-файла по сравнению с XSD-файлом?
- java Как округлить результат целочисленного деления?
- java Преобразование списка <Integer> в список <String>
- collections Фильтрация коллекций в C #
- collections Различия между HashMap и Hashtable?
- collections Как эффективно перебирать каждую запись на карте Java?
- collections Выберите N случайных элементов из списка <T> в C #
- hashmap Каков наилучший способ конвертировать массив в хеш в Ruby
- hashmap Безопасно ли получать значения из java.util.HashMap из нескольких потоков (без изменений)?
- hashmap Почему бы не позволить внешнему интерфейсу предоставлять hashCode / equals для HashMap?
- hashmap Почему AbstractCollection не реализует equals ()?
- hashtable Hashtable с многомерным ключом в C #
- hashtable Как работает хеш-таблица?
- hashtable Кортежи (или массивы) в качестве словарных ключей в C #
- hashtable Обратимый словарь для питона