java.Util.Map接口是jdk的常用接口，Map是一种数据字典，以key,value形式出现，key、value作为数据域出现在内部接口Entry<K,V>中。提供根据key查value，以及keys和values集合并遍历的方法。没什么特殊的地方，只是对于几种Map，如果能知道其数据结构和相对优劣，对于编写性能较好的程序是需要掌握这些的。
1.Hashtable
jdk的遗留类。提供了线程安全的添加、删除等接口，通过内部互斥锁Synchronized实现。
public synchronized V put(K key， V value) public synchronized V get(Object key)
2.HashMap
数据结构是数组，数组元素是单向链表。数据结构如下图：
常用方法：
put(key,value)
1）如果key为null
如果key==null，则执行putForNullKey()。HashMap只允许存在一个key为null的元素，value后值覆盖前值。
2）计算key的hash值
根据jdk的hash算法，计算key的hash值。
3）定位元素在数组中的位置
执行indexFor()方法，得到元素在数组中的index。
4）数组中已存在相同的key
遍历数组，判断数组中是否已经有相同的key，已经存在，则value后值覆盖前值，返回oldValue。
判断条件是两个key的hash值相同，并且两者的”==”或者“equals”比较返回true。如果key是String对象，则内容相同或者是同一个对象都判定为key相同；如果是自定义对象，则需要重写equals方法来规定判断标准。如果以自定义的对象作为key，则需要重写equals()和hashcode()。
5）数组中不存在该key
将元素包装为Entry类型，添加元素到数组，并将新Entry对象添加到链表头。
特点：
1）可以存储null键和null值，Hashtable不允许；
两个关键参数：initial capacity和load factor。Load factor默认是0.75，是offers a good tradeoff between time and space costs。当map元素数量大于集合容量乘以加载因子时，集合容量扩大到当前容量的两倍，并且对元素进行rehash。尽量避免rehash，如果初始容量大于最大元素数除以加载因子时，则不会发生rehash。
2）非线程安全。
典型的问题是多线程并发访问、rehash时，会产生死循环问题。可使用Collections.synchronizedMap 方法来“包装”该映射，实现并发的安全处理。如果Collections.synchronizedMap不能满足性能要求，可试试选择ConcurrentHashMap。
3）迭代的快速失败。
集合的迭代器创建之后，如果集合结构有修改，而且非调用Iterator.remove()，迭代器会抛出 ConcurrentModificationException，但是该fail-fast得不到保证的。参考iterator方法，可知在遍历Iterator期间，元素个数有变化，则出现并发问题，抛出异常。
Step1
private final class KeySet extends AbstractSet<K> {
public Iterator<K>iterator() {
return new KeyIterator();
}
publicint size() {
returnsize;
}
public boolean contains(Object o) {
return containsKey(o);
}
public boolean remove(Object o) {
return HashMap.this.removeEntryForKey(o) != null;
}
public void clear() {
HashMap.this.clear();
}
}
Step2
Iterator<K> newKeyIterator() {
retur nnew KeyIterator();
}
Step3
private final class KeyIterator extends HashIterator<K> {
public K next() {
return nextEntry().getKey();
}
}
Step4
final Entry<K,V> nextEntry() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
Entry<K,V> e = next;
if (e == null)
throw new NoSuchElementException();
if ((next = e.next) == null) {
Entry[] t = table;
while (index< t.length&& (next = t[index++]) == null)
;
}
current = e;
return e;
}
4）线程安全
HashMap为什么是非线程安全的？ConcurrentHashMap为什么是线程安全的？
HashMap数据结构是Entry数组，并发操作时，数组是被竞争的共享资源，如果读时有写操作，就会出现并发问题。
HashMap提供了fast-fail机制，使用Iterator遍历时，会比较元素更新数，如果元素数有变化，则抛出ConcurrentModificationException。
ConcurrentHashMap数据结构是Segment数组，每个数组上通过加显示锁保证了线程安全。同时，由于元素分成了多个segment，提高了并发性能。实现参考ConcurrentHashMap部分。
3.LinkedHashMap
1）数据结构
数据保存在一个数组，数组元素是双向链表。
private transient Entry<K，V>header;//数组
private static class Entry<K，V> extends HashMap.Entry<K，V>{
Entry<K，V> before， after;//双向指针
…
}
2）特点
LinkedHashMap保存了数据的插入顺序。在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的；HashMap返回key-value的顺序只与Key的hashCode有关。
LinkedHashMap也可以在构造时用带参数，按照应用次数排序。在遍历的时候会比HashMap慢，不过有种情况例外，当HashMap容量很大，实际数据较少时，遍历起来可能会比LinkedHashMap慢，因为LinkedHashMap的遍历速度只和容量有关，而HashMap的遍历速度和他的碰撞情况相关。
5.ConcurrentHashMap
1）数据结构
2）特点
a)并发安全
通过对segment对象加锁，实现了该segment内读写操作的互斥，保证了并发安全性。
b)并发性能好
ConcurrentHashMap数据保存在名为segments的数组中，锁是分别加在每个segement上的，与Hashtable、Collections.synchronizedMap相比，多个segment之间可以安全的并发操作，提高了并发性能。
代码实现
参考获取操作的实现代码。
Step1
public V get(Object key) {
int hash = hash(key.hashCode());
return segmentFor(hash).get(key, hash);
}
Step2
V get(Object key, int hash) {
if (count != 0) { // read-volatile
HashEntry<K,V> e = getFirst(hash);
while (e != null) {
if (e.hash == hash && key.equals(e.key)) {
V v = e.value;
if (v != null)
return v;
return readValueUnderLock(e); // recheck
}
e = e.next;
}
}
return null;
}
Step3
V readValueUnderLock(HashEntry<K,V> e) {
lock();
try {
return e.value;
} finally {
unlock();
}
}
6.TreeMap
TreeMap数据结构是红黑树。实现了SortMap接口，能够把它保存的记录根据键排序，默认是按键值升序排序，也可以指定排序的比较器。(数据结构及分析待补充)