Map子类重要源码分析对比&HashMap&HashTable&TreeMap&IdentityHashMap&WeakHashMap

Map是Java最常用的中最常用的集合之一。

它的子类有

HashTable
HashMap
TreeMap
IdentityHashMap
WeakHashMap

HashTable和HashMap的分析对比

参考Blog【单独的对HashMap和HashTable的分析】

【HashMap源码分析】（http://blog.csdn.net/chdjj/article/details/38553163）

【HashMap实现原理分析】

http://blog.csdn.net/vking_wang/article/details/14166593

【HashTable源码分析】(http://blog.csdn.net/chdjj/article/details/38581035)

HashTable是jdk1.0产生的，HashMap是jdk1.2产生的。HashMap其实就是在HashTable的细节上做了改动和完善。

HashTable和HashMap的时间复杂度为o(1)。空间复杂度不一定【这个是可以根据构造函数变化的】

主要不同如下

1、HashTable是线程安全的。所以跟HashMap比性能差一点。
2、HashTable键、值都不能为null，HashMap都可以为null
3、HashTable的contains（）方法容易让人产生歧义，在HashMap把它删掉了

源码分析：

不同点1

//HashTable
public synchronized V put(K key, V value)
//HashMap
public V put(K key, V value)

不同点2

//HashTable
public synchronized V put(K key, V value) {
// Make sure the value is not null
if (value == null) {
throw new NullPointerException();
}

// Makes sure the key is not already in the hashtable.
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
Entry<K,V> entry = (Entry<K,V>)tab[index];
for(; entry != null ; entry = entry.next) {
if ((entry.hash == hash) && entry.key.equals(key)) {
V old = entry.value;
entry.value = value;
return old;
}
}

addEntry(hash, key, value, index);
return null;
}

其中值不能为空非常明显，至于key不能为空，是在这句代码

int hash = key.hashCode();

hash码根据key的地址产生，key为空自然就会有空指针异常

//HashMap
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}

modCount++;
addEntry(hash, key, value, i);
return null;
}
------------------------------------------------------
private V putForNullKey(V value) {
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(0, null, value, 0);
return null;
}

判断了key值，value不用管。

不同点3

//HashTable
public synchronized boolean contains(Object value) {
if (value == null) {
throw new NullPointerException();
}

Entry<?,?> tab[] = table;
for (int i = tab.length ; i-- > 0 ;) {
for (Entry<?,?> e = tab[i] ; e != null ; e = e.next) {
if (e.value.equals(value)) {
return true;
}
}
}
return false;
}
public boolean containsValue(Object value) {
return contains(value);
}

HashTable要了这个contains主要是判断value非空的，到了HashMap这里value已经可以为空了。所以就把这个易混淆的方法丢弃了。

TreeMap

参考Blog

【TreeMap的源码分析】(http://blog.csdn.net/chenssy/article/details/26668941)

这个类与HashMap的不同

1、数据结构不同【可以说这导致了基本都不一样】

TreeMap是有序的，因为它的数据结构是红黑树【一种平衡二叉搜索树】。它的时间复杂度是log2（n);

至于源码及分析，见上面的Blog【强烈推荐一波，这个Blog对源码及红黑树的分析非常到位】

IdentityHashMap

参考Blog

【 IdentityHashMap分析】(http://blog.csdn.net/hudashi/article/details/6947625)

这个类与HashMap的主要不同有两点

1、判断key值相等的方式不同，这也是IdentityHashMap键可以重复的原因
2、数据结构不同【所以IdentityHashMap快一点】

源码如下：

不同点1

public V put(K key, V value) {
final Object k = maskNull(key);

retryAfterResize: for (;;) {
final Object[] tab = table;
final int len = tab.length;
int i = hash(k, len);

for (Object item; (item = tab[i]) != null;
i = nextKeyIndex(i, len)) {
if (item == k) {
@SuppressWarnings("unchecked")
V oldValue = (V) tab[i + 1];
tab[i + 1] = value;
return oldValue;
}
}

final int s = size + 1;
// Use optimized form of 3 * s.
// Next capacity is len, 2 * current capacity.
if (s + (s << 1) > len && resize(len))
continue retryAfterResize;

modCount++;
tab[i] = k;
tab[i + 1] = value;
size = s;
return null;
}
}

这句代码

if(item == k) ！

//HashMap
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}

modCount++;
addEntry(hash, key, value, i);
return null;
}

这句代码

if (e.hash == hash && ((k = e.key) == key || key.equals(k)))

很明显前者根据地址判断相同，后者根据key的hash码和来内容来判断

不同点2

//IdentityHashMap
transient Object[] table;

//HashMap
transient Entry[] table;

IdentityHashMap是通过数组来存储的

tab[i] = k;
tab[i + 1] = value;

至于HashMap

通过数组table+链Entry

WeakHashMap

参考Blog

【WeakhashMap分析】(http://mikewang.blog.51cto.com/3826268/880775/)

简单理解就是

WeakHashmap中【key, value】中的key，如果除了WeakHashmap自己对之外没有引用了【联系】，那么这个对象就会被gc。

下面是一个简单的代码,代码来自http://www.jb51.net/article/36948.htm

import java.util.*;
import java.util.Hashtable;
/**
* Created by hms on 2017/2/8.
*/
public class MapAnalyze {
public static void main(String[] args) {
String a = new String("a");
String b = new String("b");
Map weakmap = new WeakHashMap();
Map map = new HashMap();
map.put(a, "aaa");
map.put(b, "bbb");

weakmap.put(a, "aaa");
weakmap.put(b, "bbb");

map.remove(a);

a=null;
b=null;

System.gc();
Iterator i = map.entrySet().iterator();
while (i.hasNext()) {
Map.Entry en = (Map.Entry)i.next();
System.out.println("map:"+en.getKey()+":"+en.getValue());
}

Iterator j = weakmap.entrySet().iterator();
while (j.hasNext()) {
Map.Entry en = (Map.Entry)j.next();
System.out.println("weakmap:"+en.getKey()+":"+en.getValue());

}
}
}

/** Output

map:b:bbb

weakmap:b:bbb

*/