HashMapとHashtableの違いは？

違いは何ですかHashMapとHashtableJavaでは？

スレッド化されていないアプリケーションの方が効率的ですか？

HashMapとHashtableJavaの間にはいくつかの違いがあります。

1. Hashtableは同期されますが、同期されHashMapません。HashMap非同期のオブジェクトは通常、同期されたオブジェクトよりもパフォーマンスが高いため、これはスレッド化されていないアプリケーションに適しています。

2. Hashtablenullキーまたは値は許可されません。 HashMap1つのnullキーと任意の数のnull値を許可します。

3. HashMapののサブクラスの一つであるLinkedHashMapので、あなたが（デフォルトで挿入順です）予測可能な繰り返し順序をしたいと思うことをイベントでは、あなたが簡単に入れ替えることができ、HashMapためLinkedHashMap。を使用してHashtableいる場合、これは簡単ではありません。

同期は問題ではないので、お勧めしHashMapます。同期が問題になる場合は、もご覧くださいConcurrentHashMap。

回答の多くはHashtableが同期されていると述べていることに注意してください。 実際には、これはほとんどあなたを買いません。 同期はaccessor / mutatorメソッドで行われ、2つのスレッドが同時にマップに追加またはマップから削除するのを停止しますが、実際には、追加の同期が必要になることがよくあります。

非常に一般的なイディオムは「チェックしてから置く」ことです。つまり、でエントリを探し、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。

この質問は、候補者がコレクションクラスの正しい使用法を理解し、利用可能な代替ソリューションを認識しているかどうかを確認するために、面接でよく尋ねられます。

1. このHashMapクラスはHashtable、非同期でnullを許可することを除いて、とほぼ同じです。（HashMapnull値をキーと値として許可しますHashtableが、許可しませんnull s）。
2. HashMap は、マップの順序が長期にわたって一定であることを保証するものではありません。
3. HashMap一方、非同期されてHashtable同期されます。
4. のイテレータHashMapはフェイルセーフですが、の列挙子はフェイルセーフではHashtableありませんが、ConcurrentModificationException他のスレッドがIterator独自のremove() メソッド以外の要素を追加または削除してマップを構造的に変更するとスローされます。しかし、これは保証された動作ではなく、JVMによって最善の努力で行われます。

いくつかの重要な用語に関する注意：

1. 同期とは、一度に1つのスレッドのみがハッシュテーブルを変更できることを意味します。基本的に、それは更新を実行する前のスレッドがHashtable他のユーザーがロックが解放されるのを待つ間オブジェクトのロックを取得する必要が。
2. フェイルセーフは、反復子のコンテキスト内で関連しています。イテレータがコレクションオブジェクトで作成されていて、他のスレッドがコレクションオブジェクトを「構造的に」変更しようとすると、同時変更例外がスローされます。setコレクションを「構造的に」変更しないため、他のスレッドがメソッドを呼び出すことは可能です。ただし、を呼び出す前にset、コレクションが構造的に変更されているIllegalArgumentException場合はスローされます。
3. 構造的に変更とは、マップの構造を効果的に変更できる要素を削除または挿入することを意味します。

HashMap によって同期することができます

Map m = Collections.synchronizeMap(hashMap);

マップは、列挙オブジェクトを介した反復を直接サポートする代わりに、コレクションビューを提供します。このセクションで後述するように、コレクションビューはインターフェイスの表現力を大幅に向上させます。マップを使用すると、キー、値、またはキーと値のペアを反復できます。 Hashtable3番目のオプションはありません。Mapは、反復の途中でエントリを削除する安全な方法を提供します。Hashtableしませんでした。最後に、マップはHashtableインターフェースのマイナーな欠陥を修正します。 Hashtableには、containsというメソッドがあります。これは、Hashtablecontainsが指定された値を含む場合にtrueを返し ます。その名前を考えるとHashtable、キーがの主要なアクセスメカニズムであるため、が特定のキーを含んでいる場合、このメソッドはtrueを返すと予想されますHashtable。Mapインターフェースは、メソッドの名前を変更することにより、この混乱の原因を排除します containsValue。また、これによりインターフェースの一貫性が向上します— containsValueパラレルcontainsKey。

マップインターフェース

HashMap：Mapハッシュコードを使用して配列のインデックスを作成するインターフェイスの実装。 Hashtable：こんにちは、1998年に呼ばれました。コレクションAPIを元に戻したいと考えています。

真剣にしかし、あなたはHashtable完全に近づかないほうがいいです。シングルスレッドアプリの場合、同期の余分なオーバーヘッドは必要ありません。並行性の高いアプリの場合、偏執的な同期により、飢餓、デッドロック、または不要なガベージコレクションの一時停止が発生する可能性があります。ティム・ハウランドが指摘したように、ConcurrentHashMap代わりに使うかもしれません。

これHashTableは、Java Collections Framework（JCF）が導入される前のレガシークラスであり、後でMapインターフェースを実装するために改良されたことを覚えておいてください。そうだったVectorとStack。

したがって、他の人が指摘したようにJCFには常により良い代替案があるので、常に新しいコードでそれらから離れてください。

以下は、Javaコレクションのチートシートです。灰色のブロックには、従来のクラスHashTable、Vector、Stackが含まれています。

すでに多くの良い答えが投稿されています。新しい点をいくつか追加して要約します。

HashMapまた、Hashtableどちらもキーと値の形式でデータを格納するために使用されます。どちらもハッシュ技術を使用して一意のキーを格納しています。ただし、以下に示すHashMapクラスとHashtableクラスの間には多くの違いがあります。

HashMap

1. HashMap同期されていません。これはスレッドセーフではなく、適切な同期コードがないと多くのスレッド間で共有できません。
2. HashMap 1つのnullキーと複数のnull値を許可します。
3. HashMap JDK 1.2で導入された新しいクラスです。
4. HashMap 速いです。
5. HashMapこのコードを呼び出すことにより、を同期させることができます
   Map m = Collections.synchronizedMap(HashMap);
6. HashMap イテレーターによってトラバースされます。
7. のイテレータHashMapはフェイルファストです。
8. HashMap AbstractMapクラスを継承します。

ハッシュ表

1. Hashtable同期されます。スレッドセーフであり、多くのスレッドで共有できます。
2. Hashtable nullキーまたは値は許可されません。
3. Hashtable レガシークラスです。
4. Hashtable 遅い。
5. Hashtable 内部で同期されており、同期を解除することはできません。
6. Hashtable EnumeratorとIteratorがトラバースします。
7. の列挙子Hashtableはフェイルファストではありません。
8. Hashtable 辞書クラスを継承します。

また、読書JavaでのHashMapとHashtableの違いは何ですか？

izbが言ったことに加えて、HashMapnull値を許可しますが、null値は許可Hashtableしません。

また、Javadocsの状態と同じようにHashtable、Dictionaryクラスが拡張されているため、インターフェースは置き換えられています。Map

このチャートを見てください。それは一緒に異なるデータ構造間の比較を提供HashMapしてHashtable。比較は正確で、明確で、理解しやすいです。

Javaコレクションマトリックス

Hashtableに似てHashMapおり、同様のインターフェースを持っています。メソッドが同期さHashMapれるため、レガシーアプリケーションのサポートが必要な場合や同期が必要な場合を除いて、を使用することをお勧めしますHashtables。あなたの場合、マルチスレッドでHashMapsはないので、最善の策です。

ハッシュテーブルとハッシュマップのもう1つの重要な違いは、HashMapのイテレータはフェイルファストですが、ハッシュテーブルの列挙子はフェイルファストではなく、他のスレッドがイテレータ自身の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では、古き良きスクリプト言語のようにHashMapを作成してアクセスできることも約束されています。

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

アップデート：いいえ、彼らは1.8に着陸しません... :(

Project Coinのコレクションの拡張機能はJDK8に含まれる予定ですか？

Hashtableは同期されていますが、同期されてHashMapいません。それはHashtableより遅くなりHashmapます。

スレッド化されていないアプリのHashMap場合は、機能的には同じなので、使用します。

• HashTableは同期されます。シングルスレッドで使用している場合は、非同期バージョンであるHashMapを使用できます。非同期オブジェクトは、多くの場合、パフォーマンスが少し向上します。ちなみに、複数のスレッドがHashMapに同時にアクセスし、少なくとも1つのスレッドがマップを構造的に変更する場合、外部で同期する必要があります。Younは、以下を使用して、非同期マップを同期マップにラップできます。

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

• HashTableには、キーまたは値としてnull以外のオブジェクトのみを含めることができます。HashMapには、1つのnullキーとnull値を含めることができます。

• Mapによって返されるイテレータはフェイルファストです。イテレータの作成後、マップが構造的にいつでも変更された場合、イテレータ自身のremoveメソッド以外の方法で、イテレータはをスローしConcurrentModificationExceptionます。したがって、同時変更に直面した場合、イテレーターは、将来の未確定の時点で恣意的な非決定論的な動作のリスクを冒すのではなく、迅速かつクリーンに失敗します。一方、Hashtableのキーと要素のメソッドによって返される列挙型はフェイルファストではありません。

• HashTableとHashMapは、Java Collections Frameworkのメンバーです（Java 2プラットフォームv1.2以降、HashTableはMapインターフェースを実装するために改良されました）。

• HashTableはレガシーコードと見なされます。ドキュメントでは、スレッドセーフの高度な同時実装が必要な場合は、Hashtableの代わりにConcurrentHashMapを使用することをお勧めしています。

• HashMapは、要素が返される順序を保証しません。HashTableについても同じだと思いますが、完全にはわかりません。そのことを明確に述べているリソースは見つかりません。

HashMapそして、Hashtable同様に重要なアルゴリズムの違いがあります。誰もこれについて以前に言及したことがないので、私がそれを取り上げるのはそのためです。HashMap2つの累乗のサイズのハッシュテーブルを作成し、動的に増加させて、任意のバケットに最大で約8つの要素（衝突）が含まれるようにし、一般的な要素タイプの要素を非常によく攪拌します。ただし、Hashtable実装は、あなたが何をしているのかわかっている場合、ハッシュをよりよく、より細かく制御します。たとえば、値のドメインサイズに最も近い素数を使用してテーブルサイズを修正できます。これにより、HashMapよりもパフォーマンスが向上します。つまり、衝突が少なくなります。場合によっては。

この質問で広く議論されている明らかな違いとは別に、Hashtableはハッシュをより適切に制御できる「手動ドライブ」の車であり、HashMapは一般に良好に機能する「自動ドライブ」の対応物だと思います。

ここの情報に基づいて、私はHashMapを使用することをお勧めします。最大の利点は、イテレータを使用しない限り、Javaを反復している間はJavaで変更できないことです。

あ Collectionコンテナとも呼ばれる）は、単に複数の要素を1つの単位にグループ化するオブジェクトです。Collectionは、集計データの保存、取得、操作、通信に使用されます。コレクションフレームワーク^Wは、を表現および操作するための統合アーキテクチャです。

HashMap JDK1.2そしてハッシュテーブルは^JDK1.0、両方ともに表されているオブジェクトのグループ表すために使用されている<Key, Value>ペアを。各<Key, Value>ペアはEntryオブジェクトと呼ばれます。エントリのコレクションは、HashMapおよびのオブジェクトによって参照されますHashtable。コレクション内のキーは、一意または固有である必要があります。[マップされた値、特定のキーを取得するために使用されるため。コレクション内の値は複製できます。]

« スーパークラス、レガシー、コレクションフレームワークメンバー

Hashtableは、で導入されたレガシークラスでありJDK1.0、Dictionaryクラスのサブクラスです。From JDK1.2Hashtableは、Mapインターフェースを実装してコレクションフレームワークのメンバーを作成するように再設計されています。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）で空のハッシュテーブルを作成します。Hashtableはデフォルトの初期容量（11）と負荷係数/充填率（0.75）で空のハッシュテーブルを作成します。

« ハッシュ衝突の場合の構造変更

HashMap、Hashtableハッシュの衝突の場合、マップエントリをリンクリストに格納します。Java8からHashMap、ハッシュバケットが特定のしきい値を超えた場合、そのバケットはから切り替わりlinked list of entries to a balanced treeます。最悪の場合のパフォーマンスをO（n）からO（log n）に改善します。リストをバイナリツリーに変換するとき、ハッシュコードは分岐変数として使用されます。同じバケットに2つの異なるハッシュコードがある場合、1つはより大きく、ツリーの右側に移動し、もう1つは左側に移動すると見なされます。しかし、両方のハッシュコードが等しく、 多くても^{Java 8 SRCの場合、stackpost}HashMapは、キーが比較可能であると想定し、キーを比較して方向を決定することで、順序を維持できるようにします。HashMap 同等のキーを作成することをお勧めします。バケットサイズが到達した場合のエントリの追加についてTREEIFY_THRESHOLD = 8エントリのリンクリストをバランスツリーに変換します。バランスツリーを下回って最大エントリを削除するリンクツリーがエントリのリンクリストに再変換されます。TREEIFY_THRESHOLDUNTREEIFY_THRESHOLD = 6

« コレクションビューの反復、Fail-FastおよびFail-Safe

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

Iterator本質的にフェイルファストです。つまり、独自のremove（）メソッド以外の反復中にコレクションが変更されると、ConcurrentModificationExceptionがスローされます。どこEnumerationフェイルセーフな性質です。反復中にコレクションが変更されても、例外はスローされません。

Java APIドキュメントによると、イテレータは常に列挙よりも優先されます。

_{注意： Enumerationインターフェースの機能は、Iteratorインターフェースと同じです。さらに、Iteratorはオプションの削除操作を追加し、メソッド名が短くなっています。新しい実装では、列挙よりもイテレータの使用を検討する必要があります。}

Java 5のConcurrentMapインタフェースを導入しました：ConcurrentHashMap-非常に同時、高性能なConcurrentMap実装では、ハッシュテーブルに裏打ちされました。この実装は、取得を実行するときに決してブロックせず、クライアントが更新の同時実行レベルを選択できるようにします。これは、のドロップイン置換として意図されています。のHashtable実装に加えてConcurrentMap、に固有の「レガシー」メソッドのすべてをサポートしHashtableます。

• 各HashMapEntrys値は揮発性であるため、競合する変更と後続の読み取りに対して細粒度の一貫性が保証されます。各読み取りは、最後に完了した更新を反映しています

• イテレータと列挙型はフェイルセーフです-イテレータ/列挙型の作成以降のある時点での状態を反映しています。これにより、一貫性が低下しますが、読み取りと変更を同時に行うことができます。ConcurrentModificationExceptionはスローされません。ただし、イテレータは一度に1つのスレッドのみが使用するように設計されています。

• と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();
    }
}

« NullキーとNull値

HashMap最大1つのnullキーと任意の数のnull値を許可します。Hashtablenullが1つでもnull値も許可されない場合、キーまたは値がnullの場合、NullPointerExceptionがスローされます。^例

« 同期、スレッドセーフ

Hashtable内部で同期されます。したがって、Hashtableマルチスレッドアプリケーションで使用しても非常に安全です。as HashMapは内部的に同期されていません。したがって、HashMap外部同期のないマルチスレッドアプリケーションで使用するのは安全ではありません。メソッドHashMapを使用して外部同期できCollections.synchronizedMap()ます。

« パフォーマンス

Hashtable内部的に同期され、これは作るHashtable少しより遅いですHashMap。

@見る

• 赤黒木は一種の自己均衡二分探索木です
• HashMapJava 8のパフォーマンス向上

スレッド化されたアプリの場合、パフォーマンス要件に応じて、ConcurrentHashMapを使いこなすことがよくあります。

1. HashmapおよびHashTable店舗のキーと値の両方。

2. Hashmapとして1つのキーを保存できます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のための（ログ（N））HashMap 対中のO（N） Hashtable。

*上記の改善が適用されていないHashtable、まだ、だけにHashMap、LinkedHashMapと、ConcurrentHashMap。

FYI、現在、

• TREEIFY_THRESHOLD = 8 ：バケットに8つを超えるノードが含まれる場合、リンクリストはバランスの取れたツリーに変換されます。
• UNTREEIFY_THRESHOLD = 6 ：バケットが小さくなった場合（削除またはサイズ変更により）、ツリーはリンクリストに変換されます。

HashTableとHashMapsには5つの基本的な違いがあります。

1. マップを使用すると、キー、値、および両方のキーと値のペアを反復して取得することもできます。HashTableにはこの機能のすべてがありません。
2. Hashtableには、contains（）関数があり、使用するのが非常に混乱しています。包含の意味が少しずれているためです。キーを含むか値を含むか？理解するのは難しい。マップには、ContainsKey（）関数とContainsValue（）関数があり、非常に簡単に理解できます。
3. ハッシュマップでは、反復しながら要素を安全に削除できます。ハッシュテーブルでは不可能です。
4. HashTableはデフォルトで同期されるため、複数のスレッドで簡単に使用できます。HashMapはデフォルトでは同期されないため、単一スレッドでのみ使用できます。ただし、Collections utilクラスのsynchronizedMap（Map m）関数を使用して、HashMapを同期に変換できます。
5. HashTableはnullキーまたはnull値を許可しません。HashMapは1つのnullキーと複数のnull値を許可します。

私の小さな貢献：

1. 最初との間で最も重要な異なるHashtableとはHashMap、ということですHashMapスレッドセーフではありませんががHashtable、スレッドセーフなコレクションです。

2. との2つ目の重要な違いはパフォーマンスです。同期されていないのでHashtable、HashMapはパフォーマンスHashMapが向上しHashtableます。

3. Hashtablevsの3番目の違いHashMapは、Hashtable古いクラスであり、JavaのConcurrentHashMap代わりに使用する必要があることですHashtable。

HashMap：java.utilパッケージ内で使用可能なクラスであり、要素をキーと値の形式で格納するために使用されます。

ハッシュテーブル：コレクションフレームワーク内で認識されているレガシークラスです。

HashTableはjdkのレガシークラスであり、今後は使用しないでください。使用法をConcurrentHashMapに置き換えます。スレッドセーフを必要としない場合は、スレッドセーフではありませんが高速でメモリ使用量が少ないHashMapを使用してください。

1. Hashtableは同期されてHashMapいますが、同期されていません。
2. もう1つの違いはHashMap、の列挙子がフェイルセーフであるのに対し、のイテレーターはフェイルセーフでHashtableあることです。反復中にマップを変更すると、わかります。
3. HashMapヌル値を許可しますが、許可しHashtableません。

HashMapとHashTable

• HashMapとHashTableに関するいくつかの重要なポイント。詳細は以下をお読みください。

1）HashtableとHashmapはjava.util.Mapインターフェースを実装します2）HashmapとHashtableはどちらもハッシュベースのコレクションです。そしてハッシュに取り組んでいます。したがって、これらはHashMapとHashTableの類似点です。

• HashMapとHashTableの違いは何ですか？

1）最初の違いは、HashMapはスレッドセーフではないが、HashTable
はスレッドセーフではないことです。2）HashMapはスレッドセーフではないため、パフォーマンスの面で優れています。一方、Hashtableのパフォーマンスはスレッドセーフであるため、賢明ではありません。したがって、複数のスレッドがHashtableに同時にアクセスすることはできません。

Hashtable:

ハッシュテーブルは、キーと値のペアの値を保持するデータ構造です。キーと値の両方にnullは許可されません。NullPointerExceptionnull値を追加すると、が取得されます。同期されます。したがって、それにはコストが伴います。特定の時間に1つのスレッドのみが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はエミュレートされているので使用できますがGWT client code、そうでHashtableはありません。

古くて古典的なトピックですが、これを説明するこの役立つブログを追加したいだけです。

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

Manish Chhabraによるブログ

HashMapとHashtableの5つの主な違い

HashMapとHashtableはどちらもjava.util.Mapインターフェースを実装していますが、より効率的なコードを書くためにJava開発者が理解しなければならないいくつかの違いがあります。Java 2プラットフォームv1.2以降、HashtableクラスはMapインターフェイスを実装するように改良され、Javaコレクションフレームワークのメンバーになりました。

1. HashMapとHashtableの主な違いの1つは、HashMapが非同期であるのに対し、Hashtableは同期されていることです。つまり、Hashtableはスレッドセーフであり、複数のスレッド間で共有できますが、適切な同期がないとHashMapを複数のスレッド間で共有できません。Java 5は、Hashtableの代替であり、JavaのHashtableよりも優れたスケーラビリティを提供するConcurrentHashMapを導入しました。同期とは、一度に1つのスレッドのみがハッシュテーブルを変更できることを意味します。基本的には、ハッシュテーブルで更新を実行する前にスレッドがオブジェクトのロックを取得する必要がある一方で、他のスレッドはロックが解放されるのを待つことを意味します。

2. HashMapクラスは、nullを許可することを除いて、Hashtableとほぼ同じです。（HashMapではnull値をキーと値として使用できますが、Hashtableではnullを使用できません）。

3. HashMapとHashtableの3番目の重要な違いは、HashMapのイテレーターがフェイルファストイテレーターであるのに対し、Hashtableの列挙子はそうではなく、他のスレッドがイテレーター自身のremove（ ） 方法。しかし、これは保証された動作ではなく、最善の努力でJVMによって実行されます。これは、Javaの列挙とイテレータの重要な違いでもあります。

4. HashtableとHashMapのもう1つの注目すべき違いは、スレッドセーフと同期のため、シングルスレッド環境で使用した場合、HashtableはHashMapよりもはるかに遅いということです。したがって、同期が必要なく、HashMapが1つのスレッドでのみ使用されている場合は、JavaでHashtableを実行します。

5. HashMapは、マップの順序が長期にわたって一定であることを保証しません。

HashMapは、

Map m = Collections.synchronizedMap(hashMap);

要約すると、JavaのHashtableとHashMapの間には大きな違いがあります。たとえば、スレッドの安全性と速度などであり、スレッドの安全性が絶対に必要な場合にのみHashtableを使用します。Java5を実行している場合は、JavaでConcurrentHashMapの使用を検討してください。

HashMapとHashtableはどちらも、キーと値の形式でデータを格納するために使用されます。どちらもハッシュ技術を使用して一意のキーを格納しています。ただし、以下に示すHashMapクラスとHashtableクラスの間には多くの違いがあります。