HashMap模拟

HashMap继承自Map类，无序不可重。

他的使用方法很多博客都写了，我就写一个模拟HashMap的类。

HashMap底层是由数组和链表构造的。

Map有键值同时存储，用键找值，键不可重复的特性。我们可以简单的想一个办法，把键值对以对象的方式存储到数组中，取出的时候再通过遍历和get方法获得值。

但是这样有一个缺陷：每次取值都要遍历整个数组并作比较，非常复杂。

所以HashMap做出了这样的改进：对每一个对象取HashCode值并对数组的长度取余，把得到的值作为数组下标，这样在取值的时候就可以直接通过传入的对象的HashCode获取下标，大大简化了计算。

但是这样还有一个问题：HashCode对数组长度取余可能有重复。

所以引入链表，相同的取余值存入到链表中，在取值的时候就可以通过HashCode找到下标，再遍历对应的链表，这样依然大大简化了步骤。

就是在数组中存储链表。

package Map;

import java.util.LinkedList;

public class FinalMap {
    int size;
    LinkedList[] map = new LinkedList[999];//链表数组
    public FinalMap(){
        
    }
    /*
     * 添加的方法
     * */
    public boolean add(Object key, Object value){
        int hashCode = key.hashCode();
        int index = hashCode % map.length;
        if(map[index] == null){//如果初试值为null，就添加一个新的链表。
            LinkedList ll = new LinkedList();
            ll.add(new Node(key, value));
            map[index] = ll;
        }else{//如果不为空，则先判断键是否重复。若是，则替换值；若否，则直接添加信息。
            for(Object o : map[index])
                if(((Node)o).getKey().equals(key))
                    ((Node)o).setValue(value);
                else
                    map[index].add(new Object());
        }
        return true;
    }
    /*
     * 取值的方法
     * */
    public Object get(Object key){
        int hashCode = key.hashCode();
        int index = hashCode % map.length;
        for(Object o : map[index])
            if(((Node)o).getKey().equals(key))
                return ((Node)o).getValue();
        return null;
    }
}
/*
 * 存储的基本单元类
 * */
class Node{
    Object key;
    Object value;
    public Object getKey() {
        return key;
    }
    public void setKey(Object key) {
        this.key = key;
    }
    public Object getValue() {
        return value;
    }
    public void setValue(Object value) {
        this.value = value;
    }
    public Node(Object key, Object value) {
        this.key = key;
        this.value = value;
    }
    
}