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

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

очень распространенной идиомой является "check then put" - т. е. искать запись на карте и добавлять ее, если она еще не существует. Это никоим образом не атомарная операция независимо от того, используете ли вы Hashtable или HashMap.

эквивалентно синхронизированный HashMap может быть получен:

Collections.synchronizedMap(myMap);

но, чтобы правильно реализовать эту логику нужно дополнительные синхронизации вида:

synchronized(myMap) {
    if (!myMap.containsKey("tomato"))
        myMap.put("tomato", "red");
}

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

реализации ConcurrentMap интерфейс (например ConcurrentHashMap) решить некоторые из этого, в том числе потокобезопасная семантика check-then-act, например:

ConcurrentMap.putIfAbsent(key, value);

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

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

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

обратите внимание на некоторые важные условия

1. Synchronized означает, что только один поток может изменить хэш-таблицу в один момент времени. В принципе, это означает, что любой поток перед выполнением обновления хэш-таблицы должен будет получить блокировку объекта, в то время как другие будут ждать освобождения блокировки.
2. Fail-safe имеет отношение к контексту итераторов. Если итератор был создан на объекте коллекции и какой-либо другой поток пытается изменить объект коллекции "структурно", параллельный будет создано исключение модификации. Для других потоков возможно вызвать метод "set", так как он не изменяет коллекцию"структурно". Однако, если перед вызовом "set" коллекция была структурно изменена, будет создано "IllegalArgumentException".
3. структурная модификация означает удаление или вставку элемента, который может эффективно изменить структуру карты.

HashMap можно синхронизировать by

Map m = Collections.synchronizeMap(hashMap);

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

Map Интерфейс

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

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

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

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

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

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

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

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

Java Collection Matrix

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

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

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

HashMap

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

Hashtable

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

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

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

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

помимо всех других важных аспектов, уже упомянутых здесь, API коллекций (например, интерфейс карты) постоянно модифицируется, чтобы соответствовать "последним и самым большим" дополнениям к спецификации Java.

например, сравните итерацию карты Java 5:

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

Map<String,Integer> map = { "orange" : 12, "apples" : 15 };
map["apples"];

обновление: нет, они не приземлятся в 1.8... :(

будут ли улучшения коллекции Project Coin в JDK8?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

на HashMap JDK1.2 и Hashtable ^JDK1.0, оба используются для обозначения группы объектов, которые представлены в <Key, Value> пара. Каждый <Key, Value> пара называется

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

O (log (n)) для HashMap Vs O (n) in Hashtable.

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

FYI, в настоящее время,

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

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

существует 5 основных дифференциаций с HashTable и HashMaps.

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

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

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

2. вторая важная разница между Hashtable и HashMap производительность, поскольку HashMap не синхронизирован, он работает лучше, чем Hashtable.

3. третья разница на Hashtable vs HashMap is это Hashtable является устаревшим классом, и вы должны использовать ConcurrentHashMap на месте Hashtable в Java.

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

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

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

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

Hashtable: - это устаревший класс, который распознается внутри collection framework

Hashtable:

Hashtable - это структура данных, которая сохраняет значения пара ключ-значение. Это не позволяет null как для ключей, так и для значений. Вы получите NullPointerException Если вы добавите значение null. Он синхронизирован. Так что он приходит со своей стоимостью. Только один поток может получить доступ 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));

    }
}

HashMap и HashTable

• некоторые важные моменты о HashMap и HashTable. пожалуйста, прочитайте ниже детали.

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

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

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

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

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

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

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

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

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

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

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

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

HashMap-подкласс класса AbstractMap, тогда как Hashtable-подкласс словаря класс.

производительность :

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

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