Java集合框架有两个顶级接口，一个是collection接口，另一个是map接口，hashmap便是map接口的重要实现类。首先看map接口。根据map键值对的特性，接口中必然有相关的方法，主要是：
V get(Object key);
V put(K key, V value);
V remove(Object key);
Set<K> keySet();
Collection<V> values();
Set<Map.Entry<K, V>> entrySet();
前三个与map的操作有关，后三个与map遍历相关。
在map接口中，还定义了一个entry接口，hashmap实现本质上是一个entry的数组的链表。所以entry可以看成是hashmap的基本单元。下面是entry接口的内容，其中最核心的其实就是这三个方法：
K getKey();
V getValue();
V setValue(V value);
是对一个entry的key和value的获取以及value的修改。
下面是hashmap的实现类：
首先看一下重要的成员变量，
static final int DEFAULT_INITIAL_CAPACITY = 16;
static final float DEFAULT_LOAD_FACTOR = 0.75f;
transient Entry<K,V>[] table;
int threshold;
final float loadFactor;
transient int modCount;
再看一下构造函数：
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
// Find a power of 2 >= initialCapacity
int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1;
this.loadFactor = loadFactor;
threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
table = new Entry[capacity];
useAltHashing = sun.misc.VM.isBooted() &&
(capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
init(); }initialCapacity是一个与hashmap大小相关的参数，但是呢，他并不是最终的大小，可以看到，数组的大小其实是capacity，capacity是一个大于等于initialCapacity的2的次方，这个是通过一个while循环计算得到的，为什么必须是2的次方后面会说。loadfactor是装载因子，衡量饱满度。threashold是一个阈值，如果大于这个值，就认为hashmap太满了，碰撞的概率就很大，这时会触发resize过程，让hashmap扩容。modcount与多线程的迭代相关。table是entry的数组。
与hash有关的方法：
final int hash(Object k) {
int h = 0;
if (useAltHashing) {
if (k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h = hashSeed;
}
h ^= k.hashCode();
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
} 上述方法用于计算hash值，首先得到key的hashCode，然后再位运算，最终的hash值很均匀，原因不详。
static int indexFor(int h, int length) {
return h & (length-1);
} 这个函数用上面得到的hash值计算table的索引，为了让每一个位置都有可能容纳一个entry，我们第一个想到是的是除模运算，但是在计算机中除法的效率很低，这里使用位运算就大大提高了效率，这里也解释了为什么数组大小是2的次方，因为2的次方减去1以后就是一个全1的二进制数，做and操作就会保证索引的均匀性，否则加入某一位是0，那么这一位永远不会再索引中出现。这样就可以通过key定位table的索引了。
再看get方法：
public V get(Object key) {
if (key == null)
return getForNullKey();
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}如果key是null，就调用如下方法：
private V getForNullKey() {
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null)
return e.value;
}
return null;
} key为null的entry存放在索引为0的位置，但是位置0不一定只有key为null的value，所以需要遍历位置0的所有entry，返回key为null的value。如果key不是null，那么就调用getEntry方法：
final Entry<K,V> getEntry(Object key) {
int hash = (key == null) ? 0 : hash(key);
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
} 使用key定位索引，然后遍历索引里面的所有entry，找到key相等的value，返回，为什么要遍历，因为可能有碰撞。如果没指定key的entry，返回null。
下面是put方法：
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key);
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;
} 如果插入key为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;
}从索引0的entry数组遍历，看是否已经存在，如果是就只是更改value，此时modecount不加，说明更新不会触发迭代异常，否则就调用addEntry方法，新增一个entry。
void addEntry(int hash, K key, V value, int bucketIndex) {
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, value, bucketIndex);
}增加一个entry需要看容量是否超过了阈值，如果超过，就需要resize扩容。然后调用createEntry新增一个entry。
void createEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}这里就是调用entry的构造函数，让新的entry成为这个table槽位的第一个entry，其next指针设置为原本的第一个entry，所以新的元素都是插入到队首的。
那如果key不是null，过程也类似，通过hash值定位索引，然后在对应的table槽位中遍历entry，更新或者添加。过程一样。
最后看下扩容：
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];
boolean oldAltHashing = useAltHashing;
useAltHashing |= sun.misc.VM.isBooted() &&
(newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
boolean rehash = oldAltHashing ^ useAltHashing;
transfer(newTable, rehash);
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}扩容会新建一个容量为原来2倍的table，然后调用下面的方法把原始的entry加入到新的table：
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}这个transfer过程就是把原本的每一个entry重新计算索引，再添加到队首的过程。
这边是hashmap的一些核心的实现。
最后，注意hashmap不是线程安全的，因为比方说某一时刻两个线程都要put相同的key和value，很可能在map里面存在两个一模一样的entry，两个都检测到没有key，就调用了addentry方法。
hashtable的实现基本上鱼hasnmap是一样的，只不过对一些方法加了synchroninzed锁，hashmap是一个hashtable的轻量级实现，在多线程环境下应该使用hashtable而非hashmap，当然也可以使用其他的线程安全级别的map，或者自己封装一下hashmap。hashtable还有一个却别就是不支持null的key和value。会报异常。