HashMap概述
① 基于哈希表的Map接口的非同步实现
②允许使用null值与null键
③提供所有可选的映射操作
④不保证映射顺序，特别不保证该顺序恒久不变
HashMap数据结构
HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。
数组数组存储区间是连续的，占用内存严重，故空间复杂的很大。但数组的二分查找时间复杂度小，为O(1)；数组的特点是：寻址容易，插入和删除困难；
链表
链表存储区间离散，占用内存比较宽松，故空间复杂度很小，但时间复杂度很大，达O（N）。链表的特点是：寻址困难，插入和删除容易。
HashMap数据结构为
HashMap的主干是一个Entry数组。Entry是HashMap的基本组成单元。Entry是HashMap里面实现一个静态内部类，其重要的属性有① key ② value③ next（实现了链表） ④ hash 从属性key,value我们就能很明显的看出来Entry就是HashMap键值对实现的一个基础bean，Map里面的内容都保存在Entry[]里面。table[i]我们叫做桶（bucket），table中存放这每一个链表的头节点。
transient Entry[] table;static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;//存储指向下一个Entry的引用，单链表结构
int hash;//对key的hashcode值进行hash运算后得到的值，存储在Entry，避免重复计算
/**
* Creates new entry.
*/
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
} 简单来说，HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的，如果定位到的数组位置不含链表（当前entry的next指向null）,那么对于查找，添加等操作很快，仅需一次寻址即可；如果定位到的数组包含链表，对于添加操作，其时间复杂度依然为O(1)，因为最新的Entry会插入链表头部，仅需简单改变引用链即可，而对于查找操作来讲，此时就需要遍历链表，然后通过key对象的equals方法逐一比对查找。所以，性能考虑，HashMap中的链表出现越少，性能才会越好。
存put
这里HashMap里面用到链式数据结构的一个概念。上面我们提到过Entry类里面有一个next属性，作用是指向下一个Entry。打个比方， 第一个键值对A进来，通过计算其key的hash得到的index=0，记做:Entry[0] = A。一会后又进来一个键值对B，通过计算其index也等于0，现在怎么办？HashMap会这样做:B.next = A,Entry[0] = B,如果又进来C,index也等于0,那么C.next = B,Entry[0] = C；这样我们发现index=0的地方其实存取了A,B,C三个键值对,他们通过next这个属性链接在一起。所以疑问不用担心。也就是说数组中存储的是最后插入的元素。到这里为止，HashMap的大致实现，我们应该已经清楚了。
public V put(K key, V value) {
if (key == null)
return putForNullKey(value); //null总是放在数组的第一个链表中
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;
//如果key在链表中已存在，则替换为新value
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;
}
void addEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<K,V>(hash, key, value, e); //参数e, 是Entry.next
//如果size超过threshold，则扩充table大小。再散列
if (size++ >= threshold)
resize(2 * table.length);
}逻辑：①先判断key是否为null，是则调用
②获取key的哈希码，计算桶号（数组的索引）
③先遍历链表，若key已经存在，则替换为新value
④若不存在，则添加新entry。取出并保存头节点（table[bucketIndex]为e，替换头结点（hash,key,value,e）
⑤长度判断，重新定义长度，再散列
由于存在碰撞检测，所以HashMap中可存在hash相同，键不同的元素。
读 get
public V get(Object key) {
if (key == null)
return getForNullKey();
int hash = hash(key.hashCode());
//先定位到数组元素，再遍历该元素处的链表
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.equals(k))){ //key.equals(k)碰撞检测
return e.value;
}
return null;
}注意：尽量使用包装类作为key，减少碰撞。并且重写equals方法的时候，一定要重写hashcode方法，否则可能会出现查找不到的情况。
null key 的存取
null key总是存放在Entry[]数组的第一个元素。
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;
}
private V getForNullKey() {
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null)
return e.value;
}
return null;
}确定数组index：hashcode % table.length取模（获取桶的位置）
static int indexFor(int h, int length) {
return h & (length-1);//取模的效率太低下，发明者使用与运算，高效的hash运算
}按位取并，作用上相当于取模mod或者取余%。
这意味着数组下标相同，并不表示hashCode相同。
HashMap长度必须是2的幂次方，因为要服务于高效的哈希运算。这样才能保证Length-1的二进制形式全是1。因为假如Length-1的值为1000的话，那么其他数和1000进行与运算之后，结果就只有1000或0000这两种情况，这样就会造成大量的冲突，显然不符合Hash算法均匀分布的原则。
哈希冲突
对某个元素进行哈希运算，得到了存储地址，但是在插入的时候，发现被其他元素占用了，这就是哈希冲突。
解决方法：1.链地址法（hashmap的解决办法就是采用的链地址法）
2.开放定址法（线性探测再散列，二次探测再散列，伪随机探测再散列）
“如果HashMap的大小超过了负载因子(load factor)定义的容量，怎么办？”
默认的负载因子大小为0.75，也就是说，当一个map填满了75%的bucket时候，和其它集合类(如ArrayList等)一样，将会创建原来HashMap大小的两倍的bucket数组，来重新调整map的大小，并将原来的对象放入新的bucket数组中。这个过程叫作rehashing，因为它调用hash方法找到新的bucket位置
HashMap中的碰撞探测(collision detection)以及碰撞的解决方法
当两个对象的hashcode相同时，它们的bucket位置相同，‘碰撞’会发生。因为HashMap使用LinkedList存储对象，这个Entry(包含有键值对的Map.Entry对象)会存储在LinkedList中。这两个对象就算hashcode相同，但是它们可能并不相等。 那如何获取这两个对象的值呢？当我们调用get()方法，HashMap会使用键对象的hashcode找到bucket位置，遍历LinkedList直到找到值对象。找到bucket位置之后，会调用keys.equals()方法去找到LinkedList中正确的节点，最终找到要找的值对象使用不可变的、声明作final的对象，并且采用合适的equals()和hashCode()方法的话，将会减少碰撞的发生，提高效率。不可变性使得能够缓存不同键的hashcode，这将提高整个获取对象的速度，使用String，Interger这样的wrapper类作为键是非常好的选择。
HashMap的两种遍历方式
第一种
|
1
2
3
4
5
6
7
|
Map map =
new
HashMap();
Iterator iter = map.entrySet().iterator();
while
(iter.hasNext()) {
Map.Entry entry = (Map.Entry) iter.next();
Object key = entry.getKey();
Object val = entry.getValue();
}
|
效率高,以后一定要使用此种方式！
第二种
|
1
2
3
4
5
6
|
Map map =
new
HashMap();
Iterator iter = map.keySet().iterator();
while
(iter.hasNext()) {
Object key = iter.next();
Object val = map.get(key);
}
|
效率低,以后尽量少使用！
当重新调整HashMap大小的时候，确实存在条件竞争，因为如果两个线程都发现HashMap需要重新调整大小了，它们会同时试着调整大小。在调整大小的过程中，存储在链表中的元素的次序会反过来，因为移动到新的bucket位置的时候，HashMap并不会将元素放在链表的尾部，而是放在头部，这是为了避免尾部遍历(tail traversing)。如果条件竞争发生了，那么下一次操作就会死循环了。
1、为什么String, Interger这样的wrapper类适合作为键？ String, Interger这样的wrapper类作为HashMap的键是再适合不过了，而且String最为常用。因为String是不可变的，也是final的，而且已经重写了equals()和hashCode()方法了。其他的wrapper类也有这个特点。不可变性是必要的，因为为了要计算hashCode()，就要防止键值改变，如果键值在放入时和获取时返回不同的hashcode的话，那么就不能从HashMap中找到你想要的对象。不可变性还有其他的优点如线程安全。如果你可以仅仅通过将某个field声明成final就能保证hashCode是不变的，那么请这么做吧。因为获取对象的时候要用到equals()和hashCode()方法，那么键对象正确的重写这两个方法是非常重要的。如果两个不相等的对象返回不同的hashcode的话，那么碰撞的几率就会小些，这样就能提高HashMap的性能。
2、我们可以使用自定义的对象作为键吗？ 这是前一个问题的延伸。当然你可能使用任何对象作为键，只要它遵守了equals()和hashCode()方法的定义规则，并且当对象插入到Map中之后将不会再改变了。如果这个自定义对象时不可变的，那么它已经满足了作为键的条件，因为当它创建之后就已经不能改变了。
3、我们可以使用CocurrentHashMap来代替Hashtable吗？这是另外一个很热门的面试题，因为ConcurrentHashMap越来越多人用了。我们知道Hashtable是synchronized的，但是ConcurrentHashMap同步性能更好，因为它仅仅根据同步级别对map的一部分进行上锁。ConcurrentHashMap当然可以代替HashTable，但是HashTable提供更强的线程安全性。
扫一扫
1473
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
