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

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

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

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

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

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

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

Для многопоточных приложений часто можно обойтись ConcurrentHashMap - в зависимости от ваших требований к производительности.

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

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

2. Hashtable не поддерживает ключи или значения null. HashMap позволяет использовать один ключ null и любое количество значений null.

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

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

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

Если серьезно, вам лучше вообще держаться подальше от Hashtable. Для однопоточных приложений вам не нужны дополнительные накладные расходы на синхронизацию. Для приложений с высокой степенью параллелизма параноидальная синхронизация может привести к истощению, взаимоблокировкам или ненужным паузам при сборке мусора. Как указал Тим Хоуленд, вместо этого вы можете использовать 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.

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

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

Этот вопрос часто задают на собеседовании, чтобы проверить, понимает ли кандидат правильное использование классов коллекций и знает ли он об имеющихся альтернативных решениях.

1. Класс HashMap примерно эквивалентен Hashtable, за исключением того, что он не синхронизирован и допускает значения NULL. (HashMap допускает нулевые значения как ключ и значение, тогда как Hashtable не допускает null).
2. HashMap не гарантирует, что порядок карты останется постоянным с течением времени.
3. HashMap не синхронизирован, тогда как Hashtable синхронизирован.
4. Итератор в HashMap является отказоустойчивым, а перечислитель для Hashtable - нет, и выдает ConcurrentModificationException, если какой-либо другой поток структурно изменяет карту, добавляя или удаляя любой элемент, кроме собственного метода Iteratorremove(). Но это не гарантированное поведение, и JVM сделает все возможное.

Обратите внимание на некоторые важные термины:

1. Синхронизированный означает, что только один поток может изменять хеш-таблицу в один момент времени. По сути, это означает, что любой поток перед выполнением обновления Hashtable должен будет получить блокировку объекта, в то время как другие будут ждать снятия блокировки.
2. Отказоустойчивость важна в контексте итераторов. Если итератор был создан для объекта коллекции, и какой-то другой поток пытается изменить объект коллекции «структурно», будет сгенерировано исключение одновременной модификации. Однако другие потоки могут вызвать метод set, поскольку он не изменяет коллекцию «структурно». Однако, если до вызова set коллекция была структурно изменена, будет выброшен IllegalArgumentException.
3. Структурная модификация означает удаление или вставку элемента, который может эффективно изменить структуру карты.

HashMap может быть синхронизирован

Map m = Collections.synchronizeMap(hashMap);

Карта предоставляет представления коллекций вместо прямой поддержки итераций через объекты перечисления. Представления коллекций значительно улучшают выразительность интерфейса, как обсуждается далее в этом разделе. Карта позволяет вам перебирать ключи, значения или пары ключ-значение; Hashtable не предоставляет третьего варианта. Карта обеспечивает безопасный путь удалить записи в процессе итерации; Hashtable этого не сделал. Наконец, Map исправляет незначительный недостаток интерфейса Hashtable. Hashtable имеет метод contains, который возвращает true, если Hashtable содержит заданное значение. Учитывая его название, вы ожидаете этого метод, чтобы вернуть истину, если Hashtable содержит данный ключ, потому что ключ является основным механизмом доступа для Hashtable. Карта интерфейс устраняет этот источник путаницы, переименовав метод containsValue. Кроме того, это улучшает согласованность интерфейса - containsValue параллелен containsKey.

The Map Interface

Помимо всех других важных аспектов, уже упомянутых здесь, 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, который является несинхронизированной версией. Несинхронизированные объекты часто немного более производительны. Кстати, если несколько потоков обращаются к HashMap одновременно, и хотя бы один из потоков структурно модифицирует карту, она должна быть синхронизирована извне. Вы можете обернуть несинхронизированную карту в синхронизированную, используя:

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

• HashTable может содержать только ненулевой объект в качестве ключа или значения. HashMap может содержать один нулевой ключ и нулевые значения.

• Итераторы, возвращаемые Map, работают без сбоев, если карта структурно изменена в любое время после создания итератора любым способом, кроме собственного метода удаления итератора, итератор выдаст ConcurrentModificationException. Таким образом, перед лицом параллельной модификации итератор быстро и чисто выходит из строя, вместо того, чтобы рисковать произвольным, недетерминированным поведением в неопределенное время в будущем. В то время как Перечисления, возвращаемые методами ключей и элементов Hashtable, не работают без сбоев.

• HashTable и HashMap являются членами Платформа коллекций Java (начиная с платформы Java 2 v1.2, HashTable был модифицирован для реализации интерфейса Map).

• HashTable считается устаревшим кодом, в документации рекомендуется использовать ConcurrentHashMap вместо Hashtable, если требуется поточно-безопасная высокопараллельная реализация.

• HashMap не гарантирует порядок, в котором возвращаются элементы. Для HashTable, я думаю, это то же самое, но я не совсем уверен, я не нахожу ресурсов, которые четко заявляют об этом.

HashMaps дает вам свободу синхронизации, а отладка намного проще

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

Матрица коллекции Java

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

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

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

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

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

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

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

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

У HashTable и HashMaps есть 5 основных отличий.

1. Карты позволяют вам перебирать и извлекать ключи, значения и обе пары ключ-значение, а у HashTable нет всех этих возможностей.
2. В Hashtable есть функция contains (), которую очень сложно использовать. Потому что значение содержит несколько отклонений. Значит ли это содержит ключ или содержит значение? сложно понять. То же самое и в Maps, у нас есть функции ContainsKey () и ContainsValue (), которые очень легко понять.
3. В hashmap вы можете безопасно удалить элемент во время итерации. где это невозможно в хэш-таблицах.
4. HashTables по умолчанию синхронизированы, поэтому их можно легко использовать с несколькими потоками. Где, поскольку HashMaps не синхронизируются по умолчанию, поэтому могут использоваться только с одним потоком. Но вы все равно можете преобразовать HashMap в синхронизированный с помощью функции synchronizedMap (Map m) класса утилит Collections.
5. HashTable не допускает пустых ключей или нулевых значений. Где, поскольку HashMap допускает один нулевой ключ и несколько нулевых значений.

Поскольку Hashtable в Java является подклассом класса Dictionary, который теперь устарел из-за существования интерфейса карты, он больше не используется. Более того, нет ничего, что вы не могли бы сделать с классом, реализующим интерфейс карты, который вы можете сделать с помощью Hashtable.

Мой небольшой вклад:

1. First and most significant different between Hashtable and HashMap is that, HashMap is not thread-safe while Hashtable is a thread-safe collection.

2. Second important difference between Hashtable and HashMap is performance, since HashMap is not synchronized it perform better than Hashtable.

3. Third difference on Hashtable vs HashMap is that Hashtable is obsolete class and you should be using ConcurrentHashMap in place of Hashtable in Java.

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

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

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

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.

Старая и классическая тема, просто хочу добавить этот полезный блог, который объясняет это:

http://blog.manishchhabra.com/2012/08/the-5-main-differences-betwen-hashmap-and-hashtable/

Блог Маниша Чхабры

The 5 main differences betwen HashMap and Hashtable

HashMap and Hashtable both implement java.util.Map interface but there are some differences that Java developers must understand to write more efficient code. As of the Java 2 platform v1.2, Hashtable class was retrofitted to implement the Map interface, making it a member of the Java Collections Framework.

1. One of the major differences between HashMap and Hashtable is that HashMap is non-synchronized whereas Hashtable is synchronized, which means Hashtable is thread-safe and can be shared between multiple threads but HashMap cannot be shared between multiple threads without proper synchronization. Java 5 introduced ConcurrentHashMap which is an alternative of Hashtable and provides better scalability than Hashtable in Java.Synchronized means only one thread can modify a hash table at one point of time. Basically, it means that any thread before performing an update on a hashtable will have to acquire a lock on the object while others will wait for lock to be released.

2. The HashMap class is roughly equivalent to Hashtable, except that it permits nulls. (HashMap allows null values as key and value whereas Hashtable doesn’t allow nulls).

3. The third significant difference between HashMap vs Hashtable is that Iterator in the HashMap is a fail-fast iterator while the enumerator for the Hashtable is not and throw ConcurrentModificationException if any other Thread modifies the map structurally by adding or removing any element except Iterator’s own remove() method. But this is not a guaranteed behavior and will be done by JVM on best effort. This is also an important difference between Enumeration and Iterator in Java.

4. One more notable difference between Hashtable and HashMap is that because of thread-safety and synchronization Hashtable is much slower than HashMap if used in Single threaded environment. So if you don’t need synchronization and HashMap is only used by one thread, it out perform Hashtable in Java.

5. HashMap does not guarantee that the order of the map will remain constant over time.

Note that HashMap can be synchronized by

Map m = Collections.synchronizedMap(hashMap);

In Summary there are significant differences between Hashtable and HashMap in Java e.g. thread-safety and speed and based upon that only use Hashtable if you absolutely need thread-safety, if you are running Java 5 consider using ConcurrentHashMap in Java.

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

Hashtable:

Хеш-таблица - это структура данных, в которой хранятся значения пары ключ-значение. Нулевое значение не допускается как для ключей, так и для значений. Вы получите 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));

    }
}

HashMap:

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

    }
}

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

Hash Map не синхронизируется, следовательно, он небезопасен и не может использоваться несколькими потоками без надлежащего синхронизированного блока, тогда как Hashtable синхронизируется и, следовательно, является потокобезопасным.

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

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

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

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

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

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

Спектакль:

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

Обратитесь к http://modernpathshala.com/Article/1020/difference-between-hashmap-and-hashtable-in-java за примерами и вопросами интервью и викторины, относящимися к коллекции Java.

Помимо уже упомянутых различий, следует отметить, что начиная с Java 8, HashMap динамически заменяет узлы (связанный список), используемые в каждом сегменте, на TreeNodes (красно-черное дерево), так что даже при наличии большого количества коллизий хеширования в худшем случае при поиске - это

O (log (n)) для HashMapПротив O (n) в Hashtable.

* Вышеупомянутое улучшение еще не было применено к Hashtable, а только к HashMap, LinkedHashMap и ConcurrentHashMap.

К вашему сведению, в настоящее время

• TREEIFY_THRESHOLD = 8: если корзина содержит более 8 узлов, связанный список преобразуется в сбалансированное дерево.
• UNTREEIFY_THRESHOLD = 6: когда корзина становится слишком маленькой (из-за удаления или изменения размера), дерево преобразуется обратно в связанный список.

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

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

HashMap

1. HashMap не синхронизирован. Он не является потокобезопасным и не может использоваться многими потоками без надлежащего кода синхронизации.
2. HashMap допускает один нулевой ключ и несколько нулевых значений.
3. HashMap - это новый класс, представленный в JDK 1.2.
4. HashMap работает быстро.
5. Мы можем сделать HashMap синхронизированным, вызвав этот код
   Map m = Collections.synchronizedMap(HashMap);
6. HashMap проходит Iterator.
7. Итератор в HashMap работает без сбоев.
8. HashMap наследует класс AbstractMap.

Хеш-таблица

1. Hashtable синхронизирован. Он потокобезопасен и может использоваться многими потоками.
2. Hashtable не допускает использования нулевого ключа или значения.
3. Hashtable - это устаревший класс.
4. Hashtable медленный.
5. Hashtable внутренне синхронизирован и не может быть рассинхронизирован.
6. Hashtable проходит Enumerator и Iterator.
7. Перечислитель в Hashtable не работает без сбоев.
8. Hashtable наследует класс Dictionary.

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

Класс Hashtable является синхронизированным, то есть он предназначен для использования приложениями, которые обрабатывают многопоточные или многопоточные процессы. Синхронизированные классы менее эффективны в классическом случае приложения к процессу, поэтому класс Hashmap в целом работает быстрее. Класс HashTable не принимает значение Null ни для ключей, ни для значений, в то время как класс HashMap допускает один ключ с Null и максимально возможное количество NULL.

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

Hashtable является потокобезопасным и может использоваться несколькими потоками в приложении.

С другой стороны, HashMap не синхронизируется и не может быть доступен для нескольких потоков без дополнительного кода синхронизации. Мы можем использовать Collections.synchronizedMap() для создания поточно-ориентированной версии HashMap. Мы также можем просто создать собственный код блокировки или сделать его потокобезопасным с помощью ключевого слова synchronized.

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

Hashtable вообще не допускает null.

Мы должны использовать HashMap для несинхронизированного или однопоточного приложения.

Начиная с JDK 1.8, Hashtable устарел. Однако ConcurrentHashMap - отличная замена Hashtable. Мы должны рассмотреть возможность использования ConcurrentHashMap в приложениях с несколькими потоками.