Различия между HashMap и Hashtable?

https://stackoverflow.com/questions/40471

09-06-2019
|

Вопрос

В чем разница между HashMap и еще Hashtable на Java?

Что более эффективно для непоточных приложений?

Решение

Существует несколько различий между HashMap и Hashtable на Java:

<Ол>

Hashtable синхронизируется , тогда как HashMap нет. Это делает HashMap лучше для многопоточных приложений, поскольку несинхронизированные объекты обычно работают лучше, чем синхронизированные.

Hashtable не допускает использование нулевых ключей или значений. 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  ) решает некоторые из этих проблем, включая  поточно-ориентированную семантику check-then-act  такие как: 

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 содержит заданное значение. Учитывая его название, вы ожидаете это
 метод, чтобы вернуть истину, если Hashtable содержал данный ключ, потому что
 ключ является основным механизмом доступа для Hashtable. Карта
 Интерфейс устраняет этот источник путаницы, переименовывая метод
 containsValue. Кроме того, это улучшает согласованность интерфейса -
 СодержитValue Параллели containsKey. 


    Интерфейс карты  
	


	
		
	
	
			  HashMap : реализация интерфейса  Map , использующая хэш-коды для индексации массива.
 Hashtable : Привет, 1998, позвонил. Они хотят вернуть API своих коллекций. 

 Если серьезно, вам лучше держаться подальше от  Hashtable . Для однопоточных приложений вам не нужны дополнительные издержки синхронизации. Для приложений с высокой степенью одновременности параноидальная синхронизация может привести к голоданию, взаимоблокировкам или ненужным паузам сбора мусора. Как отметил Тим Хоулэнд, вместо этого вы можете использовать  ConcurrentHashMap . 
	


	
		
	
	
			 Имейте в виду, что  HashTable  был унаследованным классом до появления Java Collections Framework (JCF) и позднее был модернизирован для реализации интерфейса  Map . Так было с  Vector  и  Stack . 

  Поэтому всегда избегайте их в новом коде, поскольку в JCF всегда есть лучшая альтернатива , как указывали другие. 

 Вот  шпаргалка по коллекции Java  Это вы найдете полезным. Обратите внимание, что серый блок содержит устаревшие классы HashTable, Vector и Stack. 

  
	


	
		
	
	
			 В дополнение к тому, что сказал izb,  HashMap  допускает нулевые значения, а  Hashtable  - нет. 

 Также обратите внимание, что  Hashtable  расширяет класс  Dictionary , который как  состояние Javadocs  устарело и заменено интерфейсом  Map . 
	


	
		
	
	
			
Уже опубликовано много хороших ответов.Я добавляю несколько новых моментов и резюмирую их.

HashMap  и  Hashtable  оба используются для хранения  данные в форме ключа и значения.Оба используют технику хеширования для хранения уникальных ключей.Но есть много различий между классами HashMap и Hashtable, которые приведены ниже.

Хэш - карта 


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  наследует класс Dictionary.


Дальнейшее чтение  В чем разница между HashMap и Hashtable в Java?


    	


	
		
	
	
			 Посмотрите на этот график. Это обеспечивает сравнение между различными структурами данных наряду с HashMap и Hashtable. Сравнение точное, понятное и простое для понимания. 

 
	

		
	

	
			  Hashtable  аналогичен  HashMap  и имеет аналогичный интерфейс. Рекомендуется использовать  HashMap , если вам не требуется поддержка устаревших приложений или вам не нужна синхронизация, так как методы  Hashtables  синхронизируются. Так что в вашем случае, поскольку вы не многопоточны,  HashMaps  - ваш лучший выбор. 
	


	
		
	
	
			 Еще одно ключевое отличие между hashtable и hashmap заключается в том, что Iterator в HashMap является отказоустойчивым, а перечислитель для Hashtable - нет, и создает исключение ConcurrentModificationException, если какой-либо другой поток изменяет карту структурно, добавляя или удаляя любой элемент, кроме собственного удаления Iterator ( ) метод. Но это не гарантированное поведение, и JVM сделает это наилучшим образом. & Quot; 

 Мой источник:  http://javarevisited.blogspot.com /2010/10/difference-between-hashmap-and.html  	


	
		
	
	
			 Помимо всех других важных аспектов, уже упомянутых здесь, API-интерфейс коллекций (например, интерфейс карты) постоянно изменяется, чтобы соответствовать «последнему и самому большому»; дополнения к спецификации 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?  
	


	
		
	
	
			

Хэш-таблица  синхронизирован, если вы используете его в одном потоке, вы можете использовать  Хэш - карта, который является несинхронизированной версией.Несинхронизированные объекты часто немного более производительны.Кстати, если несколько потоков обращаются к HashMap одновременно, и хотя бы один из потоков изменяет карту структурно, она должна быть синхронизирована извне.Вы можете обернуть несинхронизированную карту в синхронизированную, используя :

Map m = Collections.synchronizedMap(new HashMap(...));

Хэш-таблица может содержать только ненулевой объект в качестве ключа или значения.HashMap может содержать один нулевой ключ и нулевые значения.
Итераторы, возвращаемые Map, быстры в отказоустойчивости, если map структурно модифицируется в любое время после создания итератора любым способом, кроме как через собственный метод remove итератора, итератор выдаст  ConcurrentModificationException.Таким образом, перед лицом одновременной модификации итератор выходит из строя быстро и чисто, вместо того чтобы рисковать произвольным, недетерминированным поведением в неопределенное время в будущем. Принимая во внимание , что  Перечисления, возвращаемые методами ключей и элементов Hashtable, не являются безотказными. 
HashTable и HashMap являются членами  Фреймворк Java Collections Framework  (начиная с платформы Java 2 версии v1.2, хэш-таблица была модифицирована для реализации интерфейса Map).
Хэш-таблица считается устаревшим кодом, документация рекомендует использовать  ConcurrentHashMap - карта параллелизма  вместо хэш-таблицы, если требуется потокобезопасная высококонкурентная реализация.
HashMap не гарантирует порядок, в котором возвращаются элементы.Для хэш-таблицы, я думаю, это то же самое, но я не совсем уверен, я не нахожу ресурсов, в которых это четко указано.

    	


	
		
	
	
			  HashMap  и  Hashtable  также имеют существенные алгоритмические различия. Никто не упоминал об этом раньше, поэтому я поднимаю это.  HashMap  создаст хэш-таблицу со степенью двойного размера, динамически увеличит ее так, чтобы в каждом сегменте было не более восьми элементов (коллизий), и будет очень хорошо перемешивать элементы для общих типов элементов. Однако реализация  Hashtable  обеспечивает лучший и более точный контроль над хэшированием, если вы знаете, что делаете, а именно, вы можете исправить размер таблицы с помощью, например, самое близкое простое число к размеру вашего домена значений, и это приведет к лучшей производительности, чем HashMap, то есть меньше коллизий в некоторых случаях. 

 Помимо очевидных различий, широко обсуждаемых в этом вопросе, я рассматриваю Hashtable как «ручной привод». автомобиль, в котором вы лучше контролируете хеширование и HashMap как «автоматический привод»; коллега, который в целом будет работать хорошо. 
	


	
		
	
	
			 Hashtable синхронизируется, а HashMap - нет. Это делает Hashtable медленнее, чем Hashmap. 

 Для непоточных приложений используйте HashMap, поскольку в остальном они одинаковы по функциональности. 
	


	
		
	
	
			 На основании  этой информации  я бы порекомендовал HashMap. Я думаю, что самым большим преимуществом является то, что Java не позволит вам изменять его, пока вы выполняете итерацию, если вы не сделаете это через итератор. 
	


	
		
	
	
			
A  Collection  — иногда называемый контейнером — это просто объект, который группирует несколько элементов в единое целое. Collections используются для хранения, извлечения, манипулирования агрегированными данными и передачи их по сети.Фреймворк коллекций  ^W  это унифицированная архитектура для представления коллекций и управления ими.

Тот Самый  HashMap ^JDK1.2  и хэш-таблица  ^JDK1.0, оба используются для представления группы объектов , которые представлены в  <Key, Value>  пара.Каждый  <Key, Value>  пара называется  Entry  объект.На коллекцию записей ссылается объект  HashMap  и  Hashtable.Ключи в коллекции должны быть уникальными.[поскольку они используются для извлечения сопоставленного значения определенного ключа.значения в коллекции могут дублироваться.]



« Член фреймворка суперклассов, унаследованных классов и коллекций

Hashtable - это устаревший класс, представленный в  JDK1.0, который является подклассом класса Dictionary.От  JDK1.2  Хэш-таблица переработана для реализации  Интерфейс карты  чтобы сделать членом collection 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).Где 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, столб для штабелирования}

« Итерация для просмотра коллекции, быстрая и безотказная

    +--------------------+-----------+-------------+
    |                    | Iterator  | Enumeration |
    +--------------------+-----------+-------------+
    | Hashtable          | fail-fast |    safe     |
    +--------------------+-----------+-------------+
    | HashMap            | fail-fast | fail-fast   |
    +--------------------+-----------+-------------+
    | ConcurrentHashMap  |   safe    |   safe      |
    +--------------------+-----------+-------------+


Iterator  это быстрый сбой по своей природе.т.е. он выдает ConcurrentModificationException, если коллекция изменяется во время итерации, отличной от его собственного метода remove().Где как  Enumeration  является безотказным по своей природе.Он не создает никаких исключений, если коллекция изменяется во время итерации. 

Согласно документам Java API, итератор всегда предпочтительнее перечисления. 

_{ПРИМЕЧАНИЕ:  Функциональность интерфейса перечисления дублируется интерфейсом итератора.Кроме того, Iterator добавляет необязательную операцию удаления и имеет более короткие имена методов.В новых реализациях следует рассмотреть возможность использования итератора вместо перечисления.}

В  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  не допускает даже одного нулевого ключа и нулевого значения, если ключ или значение равно null, то это вызывает исключение NullPointerException. ^Пример

« Синхронизированный, Потокобезопасный

Hashtable  внутренне синхронизирован.Таким образом, он очень безопасен в использовании  Hashtable  в многопоточных приложениях.Где как  HashMap  не синхронизирован внутренне.Поэтому его использование небезопасно  HashMap  в многопоточных приложениях без внешней синхронизации.Вы можете выполнить внешнюю синхронизацию  HashMap  используя  Collections.synchronizedMap()  способ.

« Производительность

Как  Hashtable  внутренне синхронизирован, это делает  Hashtable  немного медленнее, чем  HashMap.



@Видеть


Красно–черное дерево - это своего рода самобалансирующееся бинарное дерево поиска
Повышение производительности для  HashMap  в Java 8

    	


	
		
	
	
			 Для многопоточных приложений вы часто можете использовать 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  в Java. 
 
  
	



	
		
	
	
			  HashTable  - это устаревший класс в JDK, который не должен больше использоваться. Замените его на  ConcurrentHashMap . Если вам не требуется безопасность потоков, используйте  HashMap  который не является  threadsafe  но быстрее и использует меньше памяти. 
	


	
		
	
	
			 1) Hashtable синхронизируется, а hashmap - нет.
2) Другое отличие состоит в том, что итератор в HashMap является отказоустойчивым, а перечислитель для Hashtable - нет. Если вы измените карту во время итерации, вы узнаете. 

 3) HashMap разрешает нулевые значения в нем, а Hashtable - нет. 
	


	
		
	
	
			
Хэш-карта и хэш-таблица    


Несколько важных моментов о HashMap и HashTable.пожалуйста, ознакомьтесь с приведенными ниже подробностями.


1) Hashtable и Hashmap реализуют интерфейс java.util.Map
2) И Hashmap, и Hashtable представляют собой коллекцию, основанную на хэше.и работаю над хешированием.итак, это подобие HashMap и HashTable. 


В чем разница между HashMap и HashTable?


1) Первое отличие заключается в том, что HashMap не является потокобезопасным, В то время как HashTable является потокобезопасным

2) HashMap лучше с точки зрения производительности, потому что он не потокобезопасен.хотя производительность хэш-таблицы с точки зрения производительности не лучше, потому что она потокобезопасна.таким образом, несколько потоков не могут получить доступ к хэш-таблице одновременно.
    	


	
		
	
	
			 HashMap: это класс, доступный в пакете java.util, и он используется для хранения элемента в формате ключа и значения. 

 Hashtable: это унаследованный класс, который распознается в рамках коллекции. 
	


	
		
	
	
			
Hashtable:

Хэш-таблица  это структура данных, которая сохраняет значения пары ключ-значение.Он не допускает значения null как для ключей, так и для значений.Вы получите  NullPointerException  если вы добавите нулевое значение.Это синхронизировано.Так что это связано со своей стоимостью.Только один поток может получить доступ  Хэш-таблица  в определенное время.

Пример :

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));

    }
}


Хэш - карта:

Хэш - карта  это похоже на  Хэш-таблица  но он также принимает пару ключ-значение.Он допускает значение 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 дает вам свободу синхронизации, а отладка намного проще 
	


	
		
	
	
			  HashMap  эмулируется и поэтому может использоваться в  коде клиента GWT , тогда как  Hashtable  - нет. 
	


	
		
	
	
			  Синхронизация или потокобезопасность : 

 Хэш-карта не синхронизирована, следовательно, она не является безопасной и не может совместно использоваться несколькими потоками без надлежащего синхронизированного блока, тогда как Hashtable синхронизируется и, следовательно, является поточно-ориентированным. 

  Нулевые ключи и нулевые значения : 

 HashMap допускает один нулевой ключ и любое количество нулевых значений. Hashtable не допускает нулевые ключи или значения. 

  Итерация значений : 

 Итератор в HashMap является быстродействующим итератором, в то время как перечислитель для Hashtable не является и генерирует исключение ConcurrentModificationException, если какой-либо другой поток изменяет карту структурно, добавляя или удаляя любой элемент, кроме собственного метода Iterator удаления (). 

  Суперкласс и наследие : 

 HashMap является подклассом класса AbstractMap, тогда как Hashtable является подклассом класса Dictionary. 

  Эффективность : 

 Поскольку HashMap не синхронизируется, он быстрее по сравнению с Hashtable. 

 См.  http://modernpathshala.com/Article / 1020 / разницу-между-hashmap-and-hashtable-in-java  для примеров и вопросов интервью и викторины, связанной с коллекцией Java 
	

			

		

			



	
		
			Лицензировано под: CC-BY-SA с атрибуция
			Не связан с StackOverflow