HashMap和Hashtable之间的区别？

Java中的a HashMap和a有什么区别Hashtable？

哪个非线程应用程序更有效？

Java HashMap和HashtableJava 之间存在一些差异:

Hashtable是同步的,而HashMap不是.这HashMap对非线程应用程序更有利,因为非同步对象通常比同步对象执行得更好.

Hashtable不允许null键或值. HashMap允许一个null键和任意数量的null值.

HashMap的子类之一是LinkedHashMap,所以如果您想要可预测的迭代顺序(默认情况下是插入顺序),您可以轻松地换出HashMapfor a LinkedHashMap.如果你使用的话,这并不容易Hashtable.

由于同步不是你的问题,我建议HashMap.如果同步成为问题,您也可以查看ConcurrentHashMap.

请注意,许多答案都表明Hashtable已同步. 在实践中,这很少给你买. 访问器/ mutator方法上的同步将停止两个线程同时添加或从地图中删除,但在现实世界中,您将经常需要额外的同步.

一个非常常见的习语是"检查然后放" - 即在地图中查找条目,如果它尚不存在则添加它.无论您使用Hashtable还是HashMap,这都不是原子操作.

可以通过以下方式获得等效同步的HashMap:

Collections.synchronizedMap(myMap);

但要正确实现此逻辑,您需要额外的表单同步:

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

即使迭代Hashtable的条目(或Collections.synchronizedMap获得的HashMap)也不是线程安全的,除非您还通过附加同步保护Map不被修改.

ConcurrentMap接口的实现(例如ConcurrentHashMap)通过包含线程安全的check-then-act语义来解决其中的一些问题,例如:

ConcurrentMap.putIfAbsent(key, value);

Hashtable被认为是遗留代码.没有什么Hashtable可以使用HashMap或推导无法完成HashMap,所以对于新代码,我认为没有任何理由回到Hashtable.

在访谈中经常会问这个问题,以检查候选人是否理解收集类的正确用法,并了解可用的替代解决方案.

HashMap类大致相当于Hashtable,除了它是非同步的并且允许空值.(HashMap允许空值作为键和值,而Hashtable不允许空值).

HashMap不保证地图的顺序会随着时间的推移保持不变.

HashMap是非同步的,而Hashtable是同步的.

HashMap中的迭代器是故障安全的,而Hashtable的枚举器不是,如果任何其他线程通过添加或删除除Iterator自己的remove()方法之外的任何元素来修改地图,则抛出ConcurrentModificationException.但这不是一种保证行为,将由JVM尽最大努力完成.

关于一些重要条款的说明

同步意味着只有一个线程可以在一个时间点修改哈希表.基本上,这意味着在哈希表上执行更新之前的任何线程都必须获取对象的锁定,而其他线程将等待锁定被释放.

故障安全与迭代器的上下文相关.如果已在集合对象上创建了迭代器,并且某个其他线程尝试"在结构上"修改集合对象,则将引发并发修改异常.其他线程可以调用"set"方法,因为它不会"在结构上"修改集合.但是,如果在调用"set"之前,集合已在结构上进行了修改,则会抛出"IllegalArgumentException".

结构修改意味着删除或插入可以有效改变地图结构的元素.

HashMap可以同步

HashMap

Map提供了Collection视图,而不是通过Enumeration对象直接支持迭代.集合视图极大地增强了界面的表现力,如本节后面所述.Map允许您迭代键,值或键值对; Hashtable不提供第三种选择.Map提供了一种在迭代过程中删除条目的安全方法; Hashtable没有.最后,Map修复了Hashtable界面中的一个小缺陷.Hashtable有一个名为contains的方法,如果Hashtable包含给定值,则返回true.鉴于其名称,如果Hashtable包含给定键,则您希望此方法返回true,因为该键是Hashtable的主要访问机制.Map接口通过重命名方法containsValue消除了这种混淆的来源.此外,这提高了界面的一致性 - containsValue parallels containsKey.

地图界面

HashMap:Map使用哈希代码索引数组的接口的实现. Hashtable:嗨,1998年叫.他们想要回收他们的集合API.

说真的,你最好远离Hashtable完全.对于单线程应用程序,您不需要额外的同步开销.对于高度并发的应用程序,偏执同步可能会导致饥饿,死锁或不必要的垃圾收集暂停.就像Tim Howland指出的那样,你可以ConcurrentHashMap改用它.

请记住,HashTable在引入Java Collections Framework(JCF)之前,这是遗留类,后来为了实现Map接口而进行了改进.那是Vector和Stack.

因此,总是在新代码中远离它们,因为在JCF中总有更好的替代方案,正如其他人所指出的那样.

这是您将发现有用的Java集合备忘单.请注意,灰色块包含遗留类HashTable,Vector和Stack.

已发布许多好的答案.我添加了一些新的点并总结了它.

HashMap和Hashtable两个用于存储在键和值形式的数据.两者都使用散列技术来存储唯一键.但是下面给出了HashMap和Hashtable类之间的许多差异.

HashMap中

HashMap是非同步的.它不是线程安全的,如果没有适当的同步代码,就无法在许多线程之间共享.

HashMap 允许一个空键和多个空值.

HashMap 是JDK 1.2中引入的新类.

HashMap 很快

我们可以HashMap通过调用此代码使其同步
Map m = Collections.synchronizedMap(HashMap);

HashMap 由Iterator遍历.

迭代器HashMap是快速失败的.

HashMap 继承AbstractMap类.

哈希表

Hashtable是同步的.它是线程安全的,可以与许多线程共享.

Hashtable 不允许任何null键或值.

Hashtable 是一个遗产类.

Hashtable 是慢的.

Hashtable 是内部同步的,不能不同步.

Hashtable 由Enumerator和Iterator遍历.

枚举器输入Hashtable不是快速失败的.

Hashtable 继承Dictionary类.

进一步阅读Java中的HashMap和Hashtable有什么区别？

除了izb所说的,HashMap允许空值,而Hashtable不是.

另请注意,Hashtable扩展Dictionary该类(作为Javadocs状态)已过时并已被Map接口替换.

看看这张图表.它提供了不同数据结构与HashMap和Hashtable之间的比较.比较准确,清晰,易于理解.

Java Collection Matrix

Hashtable类似于HashMap并具有类似的界面.HashMap除非您需要支持旧应用程序或需要同步,否则建议您使用,因为Hashtables方法是同步的.因此,在您的情况下,因为您不是多线程,HashMaps所以最好的选择.

散列表和散列映射之间的另一个关键区别是HashMap中的Iterator是快速失​​败的,而Hashtable的枚举器不是,如果任何其他Thread通过添加或删除除Iterator自己的remove()方法之外的任何元素而在结构上修改映射,则抛出ConcurrentModificationException.但这不是一种保证行为,将由JVM尽最大努力完成."

我的来源:http://javarevisited.blogspot.com/2010/10/difference-between-hashmap-and.html

除了这里已经提到的所有其他重要方面,Collections API(例如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 map = { "orange" : 12, "apples" : 15 };
map["apples"];

更新:不,他们不会降落在1.8 ...... :(

Project Coin的集合增强功能将在JDK8中进行吗？

HashTable是同步的,如果您在单个线程中使用它,则可以使用HashMap,这是一个不同步的版本.非同步对象通常更具性能.顺便说一下,如果多个线程同时访问HashMap,并且至少有一个线程在结构上修改了映射,则必须在外部进行同步.您可以使用以下方法将未同步的地图包装在同步的地图中:

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

HashTable只能包含非空对象作为键或值.HashMap可以包含一个空键和空值.

Map返回的迭代器是快速失败的,如果在创建迭代器之后的任何时候对映射进行结构修改,除了通过迭代器自己的remove方法之外,迭代器将抛出一个ConcurrentModificationException.因此,在并发修改的情况下,迭代器快速而干净地失败,而不是在未来的未确定时间冒任意,非确定性行为的风险.而 Hashtable的键和元素方法返回的枚举并不是快速失败的.

HashTable和HashMap是Java Collections Framework的成员(自Java 2平台v1.2起,HashTable被改进以实现Map接口).

HashTable被认为是遗留代码,如果需要线程安全的高度并发实现,文档建议使用ConcurrentHashMap代替Hashtable.

HashMap不保证返回元素的顺序.对于HashTable,我猜它是一样的,但我不完全确定,我找不到明确说明这一点的资源.

HashMap并且Hashtable具有显着的算法差异.之前没有人提到这一点,所以这就是我提出这个问题的原因.HashMap将构造一个具有两个大小的哈希表,动态增加它,使得你在任何桶中最多有八个元素(冲突),并且会很好地激发一般元素类型的元素.但是,Hashtable如果你知道自己在做什么,那么实现提供了对哈希的更好和更精细的控制,即你可以使用最接近的质数来修复表大小到你的值域大小,这将导致比HashMap更好的性能,即更少的冲突对于某些情况.

除了在这个问题中广泛讨论的显而易见的差异之外,我认为Hashtable是一个"手动驱动"汽车,你可以更好地控制散列和HashMap作为通常表现良好的"自动驱动"对应物.

Hashtable是同步的,而HashMap则不是.这使得Hashtable比Hashmap慢.

对于非线程应用程序,请使用HashMap,因为它们在功能方面是相同的.

根据这里的信息,我建议使用HashMap.我认为最大的优点是Java会阻止你在迭代它时修改它,除非你通过迭代器完成它.

A Collection- 有时称为容器 - 只是一个将多个元素组合成一个单元的对象.Collections用于存储,检索,操作和传递聚合数据.集合框架^W是用于表示和操作集合的统一体系结构.

的HashMap JDK1.2和Hashtable ^JDK1.0,两者都用来表示一组在表示的对象的一对.每对称为Entry对象.参赛作品的收集是由对象简称HashMap和Hashtable.集合中的键必须是唯一的或独特的.[因为它们用于检索特定键的映射值.集合中的值可以重复.]

« 超类,遗产和收藏框架成员

Hashtable是一个引入的遗留类JDK1.0,它是Dictionary类的子类.从JDK1.2Hashtable重新设计实现Map接口以构成集合框架的成员.HashMap从一开始就是Java Collection Framework的成员JDK1.2.HashMap是AbstractMap类的子类.

public class Hashtable extends Dictionary implements Map, Cloneable, Serializable { ... }

public class HashMap extends AbstractMap implements Map, Cloneable, Serializable { ... }

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

public static void main(String[] args) {

    //HashMap hash = new HashMap();
    Hashtable hash = new Hashtable();
    //ConcurrentHashMap 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 e = hash.keys(); e.hasMoreElements(); ) {
                    sleepThread(1);
                    System.out.println("T2 : "+ e.nextElement());
                }

                // HashMap traverse using Iterator, Enumeration is Fail-Fast.
                /*
                for (Iterator< Entry > it = hash.entrySet().iterator(); it.hasNext(); ) {
                    sleepThread(1);
                    System.out.println("T2 : "+ it.next());
                    // ConcurrentModificationException at java.util.Hashtable$Enumerator.next
                }
                */

                /*
                Set< Entry > entrySet = hash.entrySet();
                Iterator< Entry > it = entrySet.iterator();
                Enumeration> entryEnumeration = Collections.enumeration( entrySet );
                while( entryEnumeration.hasMoreElements() ) {
                    sleepThread(1);
                    Entry 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 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();
    }
}

Map hashmap = new HashMap();

Map map = Collections.SyncronizedMap(hashmap);

import java.util.Map;
import java.util.Hashtable;

public class TestClass {

    public static void main(String args[ ]) {
    Map states= new Hashtable();
    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));

    }
}

import java.util.HashMap;
import java.util.Map;

public class TestClass {

    public static void main(String args[ ]) {
    Map states = new HashMap();
    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));

    }
}