从另一个角度来解析HashMap到底是怎么实现的,试着自己实现一个HashMap。我们就实现一些常用的方法,掌握了主要的几个方法就能知晓原理了。
把K和V封装成一个实体Entry,然后HashMap内部维护一个Entry[]数组,就可以实现最基本的功能了。
public class HashMap<K, V> {
public HashMap() {
table = new Entry[16];// 源码方案,默认16
}
public HashMap(int initialCapacity) {
int capacity = 2;
while (capacity < initialCapacity)
capacity = capacity * 2;// 源码方案,一定是2的倍数
table = new Entry[capacity];
}
private Entry<K, V>[] table;
private int size;
public V put(K key, V value) {
for (int i = 0; i < size; i++) {
Entry<K, V> e = table[i];
V oldValue = e.value;
if (key.equals(e.key)) {
e.value = value;
return oldValue;
}
}
table[size] = new Entry(key, value);
size++;
return null;
}
public V get(K key) {
for (int i = 0; i < size; i++) {
Entry<K, V> e = table[i];
if (key.equals(e.key)) {
return e.value;
}
}
return null;
}
public int size() {
return size;
}
class Entry<K, V> {
private final K key;
private V value;
public Entry(K key, V value) {
this.key = key;
this.value = value;
}
}
}
put()的时候如果数组满了就要扩容
public V put(K key, V value) {
for (int i = 0; i < size; i++) {
Entry<K, V> e = table[i];
V oldValue = e.value;
if (e.key.equals(key)) {
e.value = value;
return oldValue;
}
}
table[size] = new Entry(key, value);
size++;
if (size == table.length) {
resize();
}
return null;
}
private void resize() {
Entry<K, V>[] newTable = new Entry[table.length * 2];// 源码方案,满了就将数组长度翻倍
for (int i = 0; i < table.length; i++) {
newTable[i] = table[i];
}
table = newTable;
}
写到这里,一个最基本的HashMap就实现了。
一个合格的程序员,写完代码都应该思考下,这样写效率是不是太低了。
如果已经存了1000个值,那每次get和put都有可能需要遍历1000次,想想有没有办法可以优化。
如有有一个方法只要根据key,就可以知道在数组table的index,那就不用遍历了。比如index = key.hashcode()%2,这样index不是0就是1,显然不对,但是至少提示了我们可以把Entry分成2组进行存储,然后再去这2组里面去找我们想要的Entry。同一个index,table[index]怎么同时存储多个Entry呢?稍微改下Entry类,增加一个next
class Entry<K, V> {
private final K key;
private V value;
private Entry<K, V> next;
public Entry(K key, V value, Entry<K, V> next) {
this.key = key;
this.value = value;
this.next = next;
}
}
增加一个获取index的方法
private int indexFor(int hash, int length) {
return hash % length;// 分成length组,也确保index不越界
}
然后改造下put()和get()
public V get(K key) {
int index = indexFor(key.hashCode(), table.length);
Entry<K, V> e = table[index];
while (e != null) {
if (key.equals(e.key)) {
return e.value;
}
e = e.next;
}
return null;
}
public V put(K key, V value) {
int index = indexFor(key.hashCode(), table.length);
Entry<K, V> e = table[index];
while (e != null) {
if (key.equals(e.key)) {
V oldValue = e.value;
e.value = value;
return oldValue;
}
e = e.next;
}
/*
* 相同的index通过next连接起来,比如Entry a、b、c的index相同,put先后顺序是 c、b、a
* 那么他们的关系就是
* a.next = b
* b.next = c
* c.next = null
*/
table[index] = new Entry<K, V>(key, value, table[index]);
size++;
if (size == table.length) {
resize();
}
return null;
}
只要让index尽可能分散(即next层次尽可能浅)遍历的次数就会远远低于没改造前了,是不是感觉优化了不少。
有没有发现还有个问题,如果调用过resize()呢,那么indexFor()返回的值就会跟之前的不一样了。
解决方法就是resize()的时候把所有的Entry取出来,再根据indexFor()算法赋予给newTable[]
private void resize() {
Entry<K, V>[] newTable = new Entry[table.length * 2];
for (int i = 0; i < table.length; i++) {
Entry<K, V> e = table[i];
if (e != null) {
do {
Entry<K, V> next = e.next;
int index = indexFor(e.key.hashCode(), newTable.length);
Entry<K, V> oldEntry = newTable[index];
newTable[index] = e;
newTable[index].next = oldEntry;
e = next;
} while (e != null);
}
}
table = newTable;
}
写到这里,应该基本掌握了HashMap的原理,当然源码还是比这复杂一些,比如我没处理key==null的情况,还有一些其他方法没有实现,JDK1.8引入了红黑树,当链表长度超过8的时候,使用红黑树。
其实HashMap源码里获取index,会对key.hashCode()再次加工,让index更加分散,int index = hash(key) & (length -1)
int hash(K key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
上文我们自己写的indexFor方法是index = hashCode%length,为什么JDK要写成index=hash&(length – 1),关键点在于HashMap设定的length是2的幂次方,那么hashCode%length就等同于hashCode & (length – 1),2的幂次方-1有个特点就是高位都是0,低位全是1,那hashCode&(length – 1)时,hashCode只有低位参与运算,为了优化、降低碰撞的概率,让hashCode的高位也参与运算,就有了hash=hashCode^(hashCode>>>16)
再说说hashCode()和equals()
我们知道HashMap里存取都是先去取table[index],而index是根据key.hashCode()来生成的,看Object类
public native int hashCode();
public boolean equals(Object obj) {
return (this == obj);
}
hashCode()就是返回内存地址,而equals()直接判断内存地址,举个例子
class Student {
public int id;
public String name;
}
Student a = new Student();
Student b = new Student();
a.id = 1;
a.name = "小明";
b.id = 1;
b.name = "小明";
那么a.equals(b)就是false,而且a.hashCode()也和b.hashCode()不相等
如果用Student做HashMap的key,我们显然想要的是a和b就是同一个key,那么我们只能自己重写这2个方法了,比如
class Student {
public int id;
public String name;
public int hashCode(){
return id + name.hashCode();
}
public boolean equals(Student s){
return s.id == id && s.name.equals(name);
}
}
为什么我们用String、Integer等做key没有问题,是因为它们已经实现了这两个方法。
总得来说,equals()返回true,那么hashCode()必须相等,而hashCode()相等,equals()可以返回false
额外说下HashSet,由于比较简单,就不开新篇
public HashSet() {
map = new HashMap<>();
}
private static final Object PRESENT = new Object();
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
内部维护一个map,把element当做key,put到map,这样就能确保HashSet的值是唯一的了,非常简单。