[java] HashMap과 Hashtable의 차이점은 무엇입니까?


Answers

많은 해답은 Hashtable이 동기화되어 있음을 나타냅니다. 실제로 이것은 당신을 거의 사지 않습니다. 액세서 / 뮤 테이타 메소드의 동기화는지도에서 동시에 추가하거나 제거하는 두 개의 스레드를 중지하지만 현실 세계에서는 종종 추가 동기화가 필요합니다.

매우 일반적인 관용구는 "확인한 다음"넣는 것입니다. 즉, 맵에서 항목을 찾고 이미 존재하지 않으면 추가하십시오. 이것은 Hashtable 또는 HashMap을 사용하는 어떤 방식 으로든 원자 연산이 아닙니다.

등가 적으로 동기화 된 HashMap은 다음과 같은 방법으로 얻을 수 있습니다.

Collections.synchronizedMap(myMap);

그러나이 논리를 올바르게 구현하려면 다음과 같은 형식의 추가 동기화 가 필요합니다.

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

Hashtable의 엔트리 (또는 Collections.synchronizedMap에 의해 취득 된 HashMap)를 반복해도 (자), 추가적인 동기화에 의해 맵이 변경되지 않는 한, thread로부터는 안전하지 않습니다.

ConcurrentMap 인터페이스 (예 : ConcurrentHashMap )의 구현은 다음 ConcurrentMap 같은 스레드 안전성 검사 - 실행 - 의미 체계를 포함하여이 중 일부를 해결합니다.

ConcurrentMap.putIfAbsent(key, value);
Question

Java에서 HashMapHashtable 의 차이점은 무엇입니까?

비 스레드 응용 프로그램에 더 효율적인 방법은 무엇입니까?




HashTable 및 HashMaps에는 5 가지 기본 차이가 있습니다.

  1. 지도를 사용하면 키, 값 및 두 키 - 값 쌍을 반복하고 검색 할 수 있습니다. 여기서 HashTable에는이 모든 기능이 없습니다.
  2. Hashtable에는 contains ()라는 함수가 있는데, 이것은 매우 혼란 스럽다. contains의 의미가 약간 다르기 때문에. 그것이 키를 포함하고 있거나 값을 가지고 있다는 것을 의미합니까? 이해하기가 어렵다. 지도에서와 마찬가지로 ContainsKey () 및 ContainsValue () 함수도 매우 이해하기 쉽습니다.
  3. 해시 맵에서는 반복하면서 요소를 안전하게 제거 할 수 있습니다. 해시 테이블에서는 불가능합니다.
  4. HashTables는 기본적으로 동기화되므로 여러 스레드에서 쉽게 사용할 수 있습니다. HashMaps가 기본적으로 동기화되지 않았으므로 단일 스레드에서만 사용할 수 있습니다. 그러나 Collections util 클래스의 synchronizedMap (Map m) 함수를 사용하여 HashMap을 동기화하도록 변환 할 수 있습니다.
  5. HashTable은 null 키 또는 null 값을 허용하지 않습니다. HashMap은 하나의 null 키와 여러 개의 null 값을 허용합니다.



해시 테이블과 해시 맵의 또 다른 주요한 차이점은 HashMap의 Iterator는 fail-fast이지만 Hashtable의 열거자는 존재하지 않고 다른 Thread가 Iterator 자체의 remove () 메소드를 제외한 모든 요소를 ​​추가 또는 제거하여 구조적으로 수정하면 ConcurrentModificationException을 던진다는 점입니다. 그러나 이것은 보장 된 행동이 아니며 JVM이 최선의 노력을 다할 것입니다. "

내 출처 : http://javarevisited.blogspot.com/2010/10/difference-between-hashmap-and.html




HashTable 은 더 이상 사용해서는 안되는 JDK의 레거시 클래스입니다. ConcurrentHashMap 사용하여 그것을 대체하십시오. 스레드 안전성이 필요하지 않은 경우 HashMap 을 사용하십시오. HashMap 은 스레드 세이프는 아니지만 더 빠른 메모리를 사용합니다.




HashMap : 해시 코드를 사용하여 배열을 인덱싱하는 Map 인터페이스의 구현입니다. Hashtable : 안녕하세요. 1998 년에 전화했습니다. 그들은 그들의 콜렉션 API를 되돌리기를 원합니다.

진지하게, 당신은 Hashtable 에서 멀리 떨어져있는 것이 좋습니다. 단일 스레드 응용 프로그램의 경우 추가 오버 헤드가 필요하지 않습니다. 동시 처리가 많은 앱의 경우 편집증 동기화로 기아 상태, 교착 상태 또는 불필요한 가비지 수집 일시 중지가 발생할 수 있습니다. Tim Howland와 마찬가지로 ConcurrentHashMap 대신 사용할 수 있습니다.




  • HashTable 은 동기화되어 있습니다. 단일 스레드에서 사용하는 경우 동기화되지 않은 버전 인 docs.oracle.com/javase/7/docs/api/java/util/HashMap.html 을 사용할 수 있습니다. 동기화되지 않은 객체는 종종 약간 더 효과적입니다. 여러 스레드가 동시에 HashMap에 액세스하고 스레드 중 하나 이상이 구조적으로 맵을 수정하는 경우 외부에서 동기화해야합니다. 윤은 동기화되지 않은 맵을 동기화 된 맵으로 래핑 할 수 있습니다.

    Map m = Collections.synchronizedMap(new HashMap(...));
    
  • HashTable에는, 키 또는 값으로서의 null 이외의 오브젝트만을 포함 할 수가 있습니다. HashMap은 하나의 null 키와 null 값을 포함 할 수 있습니다.

  • Map에 의해 리턴 된 반복자는 패스트 패스트입니다. 반복자가 작성된 후 언제라도 구조체가 수정되면, 반복자 자신의 remove 메소드를 통하는 경우를 제외하고는 반복자는 ConcurrentModificationException 을 던집니다. 따라서 동시 수정이 이루어지면 반복자는 미래에 예측할 수없는 시간에 임의의 비 결정적 동작을 위험에 빠뜨리는 대신 빠르고 신속하게 실패합니다. Hashtable의 키와 엘리먼트 메소드에 의해 리턴 된 Enumeration은 fail-fast가 아닙니다.

  • HashTable과 HashMap은 Java Collections Framework의 멤버입니다 (Java 2 플랫폼 v1.2 이후, HashTable은 Map 인터페이스를 구현하기 위해 개조되었습니다).

  • HashTable은 레거시 코드로 간주되므로 스레드 안전성이 높은 동시 구현이 필요한 경우 Hashtable 대신 ConcurrentHashMap 을 사용하는 것이 좋습니다.

  • HashMap는 요소가 반환되는 순서를 보증하지 않습니다. HashTable의 경우 동일하지만 같지는 않지만 확실하지는 않습니다. ressource를 찾지 못했습니다.




HashMaps gives you freedom of synchronization and debugging is lot more easier




이 질문은 종종 인터뷰에서 후보자가 수집 수업의 올바른 사용법을 이해하고 있는지 확인하고 사용 가능한 대체 해결책을 알고 있는지 확인합니다.

  1. HashMap 클래스는 Hashtable과 거의 동일하지만, 동기화되지 않고 null을 허용한다는 점만 다릅니다. (HashMap은 null 값을 키와 값으로 허용하지만 Hashtable은 null을 허용하지 않습니다.)
  2. HashMap는지도의 순서가 시간이 지남에 따라 일정하게 유지 될 것이라고 보장하지 않습니다.
  3. HashMap은 동기화되지 않은 반면 HashMap은 동기화되지 않습니다.
  4. HashMap의 Iterator는 Hashtable의 열거자가없는 동안은 안전합니다. 다른 Thread가 Iterator 자신의 remove () 메소드를 제외한 요소를 추가하거나 제거하여 구조적으로 맵을 수정하면 ConcurrentModificationException을 던집니다. 그러나 이것은 보장 된 행동이 아니며 최선의 노력을 기울여 JVM에 의해 수행됩니다.

몇몇 중요한 기간에 주

  1. 동기화 됨은 하나의 스레드 만이 한 시점에서 해시 테이블을 수정할 수 있음을 의미합니다. 기본적으로, 해시 테이블에서 업데이트를 수행하기 전에 모든 스레드가 객체에 대한 잠금을 획득해야하고 다른 스레드는 잠금을 해제 할 때까지 대기해야 함을 의미합니다.
  2. 페일 세이프는 반복자의 컨텍스트와 관련이 있습니다. 반복자가 콜렉션 객체로 작성되어 다른 thread가 「구조적으로」콜렉션 객체를 변경하려고하면 (자), 병행 변경 예외가 Throw됩니다. 그러나 "구조적으로"컬렉션을 수정하지 않으므로 다른 스레드가 "set"메서드를 호출 할 수 있습니다. 다만, 「set」를 호출하기 전에, 컬렉션이 구조적으로 변경되었을 경우는, 「IllegalArgumentException」가 Throw됩니다.
  3. 구조적으로 수정이란지도의 구조를 효과적으로 변경할 수있는 요소를 삭제하거나 삽입하는 것을 의미합니다.

HashMap은 다음과 같이 동기화 할 수 있습니다.

Map m = Collections.synchronizeMap(hashMap);

Map는 Enumeration 객체를 통해 반복을 직접 지원하는 대신 Collection 뷰를 제공합니다. 컬렉션 뷰는이 섹션의 뒷부분에서 설명하는 것처럼 인터페이스의 표현력을 크게 향상시킵니다. 지도를 사용하면 키, 값 또는 키 - 값 쌍을 반복 할 수 있습니다. Hashtable은 세 번째 옵션을 제공하지 않습니다. Map은 반복되는 동안 엔트리를 제거하는 안전한 방법을 제공합니다. Hashtable은 그렇지 않았습니다. 마지막으로 Map은 Hashtable 인터페이스의 사소한 결점을 수정합니다. Hashtable에는 contains라는 메서드가 있는데, Hashtable에 지정된 값이 들어 있으면 true를 반환합니다. 그 이름이 주어지면 (자), Hashtable가 Hashtable의 주 액세스기구이기 (위해) 때문에, Hashtable가 지정된 키를 포함한 경우에,이 메소드가 true를 돌려 줄 것을 기대할 수 있습니다. Map 인터페이스는 containsValue 메소드의 이름을 변경함으로써 혼란의 근원을 제거합니다. 또한 이것은 인터페이스의 일관성을 향상시킵니다 - containsValue parallel contains containsKey.

맵 인터페이스




Hashtable:

Hashtable is a data structure that retains values of key-value pair. It doesn't allow null for both the keys and the values. You will get a NullPointerException if you add null value. It is synchronized. So it comes with its cost. Only one thread can access HashTable at a particular time.

:

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 is like Hashtable but it also accepts key value pair. It allows null for both the keys and the values. Its performance better is better than HashTable , because it is 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));

    }
}



Java에서 HashMapHashtable의 차이점 :

1) 스레드 안전

  • HashTable은 내부적으로 동기화됩니다.
  • 따라서 다중 스레드 응용 프로그램에서 HashTable을 사용하는 것이 매우 안전합니다.
  • HashMap가 내부적으로 동기화되지 않은 곳.
  • 따라서 외부 동기화없이 다중 스레드 응용 프로그램에서 HashMap을 사용하는 것은 안전하지 않습니다.
  • Collections.synchronizedMap () 메서드를 사용하여 HashMap을 외부에서 동기화 할 수 있습니다.

2) 상속 된

  • HashMap과 HashTable 모두 Map 인터페이스를 구현하지만 두 개의 다른 클래스를 확장합니다.
  • HashMap은 AbstractMap 클래스를 확장합니다. HashTable은 java의 레거시 클래스 인 Dictionary 클래스를 확장합니다.

3) Null 키와 Null 값

  • HashMap은 최대 하나의 널 (NULL) 키와 임의의 수의 널값을 허용합니다.
  • HashTable은 하나의 null 키와 null 값조차 허용하지 않습니다.

4) 순회

  • HashMap은 HashMap의 요소를 가로 지르는 데 사용되는 Iterator만을 반환합니다.
  • HashTable은 HashTable의 요소를 탐색하는 데 사용할 수있는 Iterator 및 Enumeration을 반환합니다.

5) 페일 세이프 대 페일 세이프

  • HashMap에 의해 리턴 된 Iterator는, 본질적으로 페어 패스트입니다. 즉, iterator 자신의 remove () 메소드 이외의 Iterator의 작성 후에 HashMap가 변경되었을 경우, ConcurrentModificationException를 Throw합니다.
  • 한편, HashTable에 의해 리턴 된 Enumeration은 본질적으로 fail-safe입니다. 즉, Enumeration을 생성 한 후 HashTable을 수정하면 예외가 발생하지 않습니다.

6) 성능

  • HashTable은 내부적으로 동기화되기 때문에 HashTable을 HashMap보다 약간 느리게 만듭니다.

7) 레거시 수업

  • HashTable은 레거시 클래스입니다.
  • 그것은 거의 비추천으로 인한 것으로 간주됩니다.
  • JDK 1.5부터 ConcurrentHashMap은 HashTable보다 더 나은 옵션으로 간주됩니다.

8) Member of Java Collection Framework

  • HashMap은 JDK 1.2에 처음 소개 된 시점부터 Java Collection Framework의 멤버입니다.
  • 그러나 JDK 1.2 이전에는 HashTable이있었습니다. JDK 1.2부터 Map 인터페이스를 구현하여 컬렉션 프레임 워크의 멤버로 만들었습니다.

비 스레드 응용 프로그램에 더 효율적인 방법은 무엇입니까?

  • Hashtable은 동기화되지만 Hashtable은 동기화되지 않습니다.

  • 이것은 동기화되지 않은 객체가 일반적으로 동기화 된 객체보다 잘 수행되기 때문에 비 스레드 응용 프로그램 에서 HashMap을 더 잘 만듭니다.




이미 많은 좋은 답변이 게시되어 있습니다. 몇 가지 새로운 점을 추가하고 요약합니다.

HashMapHashtable 은 키와 값 형식으로 데이터 를 저장하는 데 사용됩니다. 둘 다 고유 키를 저장하기 위해 해싱 기술을 사용하고 있습니다. 그러나 아래에 주어진 HashMap과 Hashtable 클래스에는 많은 차이점이 있습니다.

HashMap

1) HashMap 가 비동기입니다. 그것은 스레드가 안전하지 않으며 적절한 동기화 코드가없는 여러 스레드간에 공유 될 수 없습니다.
2) HashMap 은 하나의 널 (null) 키와 복수의 널값을 허용합니다.
3) HashMap 은 JDK 1.2에서 소개 된 새로운 클래스입니다.
4) HashMap 이 빠릅니다.
5)이 코드를 호출하여 HashMap 을 동기화 된 상태로 만들 수 있습니다.
Map m = Collections.synchronizedMap(HashMap);
6) HashMap 은 Iterator에 의해 트래버스됩니다.
7) HashMap Iterator는 fail-fast입니다.
8) HashMap AbstractMap 클래스를 상속받습니다.

Hashtable

1) Hashtable 이 동기화됩니다. 스레드로부터 안전하며 많은 스레드와 공유 할 수 있습니다.
2) Hashtable 은 null 키 또는 값을 허용하지 않습니다.
3) Hashtable 은 레거시 클래스입니다.
4) Hashtable 이 느립니다.
5) Hashtable 은 내부적으로 동기화되어있어서 비동기화할 수 없습니다.
6) Hashtable 은 Enumerator와 Iterator에 의해 트래버스됩니다.
7) Hashtable 열거자는 실패하지 않습니다.
8) Hashtable Dictionary 클래스를 상속받습니다.

추가 정보 Java의 HashMap과 Hashtable의 차이점은 무엇입니까?




스레드 된 응용 프로그램의 경우 성능 요구 사항에 따라 ConcurrentHashMap에서 벗어날 수 있습니다.




1. HashmapHashTable 모두 키와 값을 저장합니다.

2. Hashmap 은 하나의 키를 null 로 저장할 수 있습니다. Hashtablenull 저장할 수 없습니다.

3. HashMap 은 동기화되지 않지만 Hashtable 은 동기화됩니다.

4. HashMapCollection.SyncronizedMap(map) 과 동기화 될 수 있습니다.

Map hashmap = new HashMap();

Map map = Collections.SyncronizedMap(hashmap);



이 도표를보십시오. HashMap 및 Hashtable과 함께 다른 데이터 구조 간의 비교를 제공합니다. 비교는 정확하고 명확하며 이해하기 쉽습니다.

Java Collection Matrix




Collection 때때로 컨테이너라고도 함)은 단순히 여러 요소를 단일 단위로 그룹화하는 객체입니다. Collection 은 집계 데이터를 저장, 검색, 조작 및 전달하는 데 사용됩니다. 컬렉션 프레임 워크 W 는 컬렉션을 나타내고 조작하기위한 통일 ​​된 아키텍처입니다.

HashMap JDK1.2 와 Hashtable JDK1.0 은 모두 <Key, Value> 쌍으로 표현되는 객체 그룹을 나타내는 데 사용됩니다. 각 <Key, Value> 쌍을 Entry 객체라고합니다. Entry 컬렉션은 HashMapHashtable 의 객체에 의해 참조됩니다. 컬렉션의 키는 고유하거나 고유해야합니다. [매핑 된 값에 특정 키를 검색하는 데 사용됩니다. 컬렉션의 값을 복제 할 수 있습니다.]

« 수퍼 클래스, 레거시 및 콜렉션 Framework 멤버

Hashtable은 Dictionary 클래스의 서브 클래스 인 JDK1.0 에서 소개 된 레거시 클래스입니다. JDK1.2 Hashtable은 Map 인터페이스 를 구현하여 컬렉션 프레임 워크의 멤버가되도록 다시 엔지니어링되었습니다. HashMap은 JDK1.2 에서 처음 소개 된 시점부터 Java Collection Framework의 멤버입니다. 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 { ... }

« 초기 용량 및 부하율

용량은 해시 테이블의 버킷 수이며 초기 용량은 단순히 해시 테이블을 만들 때의 용량입니다. 해시 테이블은 열려 있습니다. " hash collision "의 경우 단일 버킷은 여러 항목을 저장하므로 순차적으로 검색해야합니다. 로드 계수는 해시 테이블의 용량이 자동으로 증가하기 전에 해시 테이블이 얼마나 채워지는지 측정합니다.

HashMap는 디폴트의 초기 용량 (16) 과 디폴트의 부하 계수 (0.75)로 하늘의 해시 테이블을 구축합니다. Where as Hashtable constructs empty hashtable with a default initial capacity (11) and load factor/fill ratio (0.75).

« Structural modification in case of hash collision

HashMap , Hashtable in case of hash collisions they store the map entries in linked lists. From Java8 for HashMap if hash bucket grows beyond a certain threshold, that bucket will switch from linked list of entries to a balanced tree . which improve worst-case performance from O(n) to O(log n). While converting the list to binary tree, hashcode is used as a branching variable. If there are two different hashcodes in the same bucket, one is considered bigger and goes to the right of the tree and other one to the left. But when both the hashcodes are equal, HashMap assumes that the keys are comparable, and compares the key to determine the direction so that some order can be maintained. It is a good practice to make the keys of HashMap comparable . On adding entries if bucket size reaches TREEIFY_THRESHOLD = 8 convert linked list of entries to a balanced tree, on removing entries less than TREEIFY_THRESHOLD and at most UNTREEIFY_THRESHOLD = 6 will reconvert balanced tree to linked list of entries. Java 8 SRC , stackpost

« Collection-view iteration, Fail-Fast and Fail-Safe

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

Iterator is a fail-fast in nature. ie it throws ConcurrentModificationException if a collection is modified while iterating other than it's own remove() method. Where as Enumeration is fail-safe in nature. It doesn't throw any exceptions if a collection is modified while iterating.

According to Java API Docs, Iterator is always preferred over the Enumeration.

NOTE: The functionality of Enumeration interface is duplicated by the Iterator interface. In addition, Iterator adds an optional remove operation, and has shorter method names. New implementations should consider using Iterator in preference to Enumeration.

In Java 5 introduced ConcurrentMap Interface : ConcurrentHashMap - a highly concurrent, high-performance ConcurrentMap implementation backed by a hash table. This implementation never blocks when performing retrievals and allows the client to select the concurrency level for updates. It is intended as a drop-in replacement for Hashtable : in addition to implementing ConcurrentMap , it supports all of the "legacy" methods peculiar to Hashtable .

  • Each HashMapEntry s value is volatile thereby ensuring fine grain consistency for contended modifications and subsequent reads; each read reflects the most recently completed update

  • Iterators and Enumerations are Fail Safe - reflecting the state at some point since the creation of iterator/enumeration; this allows for simultaneous reads and modifications at the cost of reduced consistency. They do not throw ConcurrentModificationException. However, iterators are designed to be used by only one thread at a time.

  • Like Hashtable but unlike HashMap , this class does not allow null to be used as a key or value.

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 Keys And Null Values

HashMap allows maximum one null key and any number of null values. Where as Hashtable doesn't allow even a single null key and null value, if the key or value null is then it throws NullPointerException. Example

« Synchronized, Thread Safe

Hashtable is internally synchronized. Therefore, it is very much safe to use Hashtable in multi threaded applications. Where as HashMap is not internally synchronized. Therefore, it is not safe to use HashMap in multi threaded applications without external synchronization. You can externally synchronize HashMap using Collections.synchronizedMap() method.

« Performance

As Hashtable is internally synchronized, this makes Hashtable slightly slower than the HashMap .

@See




Related