仿源码重写 HashMap java实现

自定义HashMap

方案采用：

定址：除留余数法

冲突：拉链法

自动扩容：threshHold阈值，超过容量0.8则自动扩容

public class MyHashMap<K,V> {
	
	Node<K,V>[] table; 
	int size = 8;    //初始大小8
	int threshHold = 0;
	
	public MyHashMap() {
		table = new Node[size];    
	}
	
	/*
	 * put前先resize，  定义tab=resize后的table。
	 * 根据hash得到下标，在tab[index]链中循环，查找有咩有相同的KV，有则覆盖
	 * 没有则在队尾添加， threshHold++
	 */
	public void put(K key, V value) {    //定义
		resize();
		Node<K,V>[] tab = table;    Node<K,V> tabNode;    int index;
		int hash = hash(key);
	    if ((tabNode = tab[index = (size - 1) & hash]) == null)       //取余操作，如果tab[location]没有值，直接插入
            tab[index] = new Node(hash, key, value, null);
	    else {							
	    	Node<K,V> temp;    K k;
	    	if (tabNode.hash == hash &&  ((k = tabNode.key) == key || (key != null && key.equals(k)))) //如果第一个就相同，直接修改值
	    		tabNode.setValue(value);
	    	else {
	    		for (int Count = 0; ; ++Count) {     //判断有重复就覆盖原值，没有重复就在队尾添加
                    if ((temp = tabNode.next) == null) {
                        tabNode.next = new Node(hash, key, value, null);
                        break;
                    }
                    if (temp.hash == hash && ((k = temp.key) == key || (key != null && key.equals(k)))) {
                    	temp.setValue(value);  break;
                    }
                    tabNode = temp;
                }
	    	}
	    }
	    threshHold++;
	}
	
	
	public V get(K key) {
		int hash = hash(key);
		Node<K, V> tabNode = table[(size - 1) & hash];
		if(tabNode == null)
			return null;
		K k;
		for (int Count = 0; ; ++Count) {
            if (tabNode.hash == hash && ((k = tabNode.getKey()) == key || key.equals(k))) {
            	return tabNode.getValue();
            }
            if((tabNode = tabNode.next) == null) {
            	return null;
            }
        }
	}
	
	public void resize() {
		if(threshHold < size * 0.75)
			return ;
		else {
			Node<K,V>[] newTab;   int newCap = size * 2;
			Node<K,V>[] oldTab = table;     int oldCap = size;
			size = newCap;
			newTab = new Node[size];
	        for (int j = 0; j < oldCap; ++j) {
	            Node<K,V> e;
	            if ((e = oldTab[j]) != null) {
	                oldTab[j] = null;
	                if (e.next == null)             //oldTab[j]中只有一个node，直接将node传给newTab
	                    newTab[e.hash & (newCap - 1)] = e;
	                else {       // preserve order
	                	Node<K,V> insertNode;    Node<K,V> newTabNode; 
	                    Node<K,V> next;
	                    do {            //将e链所连的值全都链接给newTab
	                        next = e.next;		insertNode = e;		insertNode.next = null;
	                        if (newTab[(newCap - 1) & insertNode.hash] == null) //如果newTab[i]没有值，直接将e传给新表
	                        	newTab[(newCap - 1) & e.hash] = insertNode;
	                        else {									//否则顺着链往下连
	                        	newTabNode = newTab[(newCap - 1) & insertNode.hash];
	                        	while(newTabNode.next != null)
	                        		newTabNode = newTabNode.next;
	                        	newTabNode.next = insertNode;
	                        }
	                    } while ((e = next) != null);
	                   
	                }
	            }
	        }
	        table = newTab;
		}
		
	}
	
    static final int hash(Object key) {         //获取K对应的哈希值
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);   //>>>无符号右移
    }
	
    
	class Node<K,V>{
		K key;
		V value;
		Node<K,V> next;
		final int hash;
		
        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }
		
		public K getKey() {
			return key;
		}
		public void setKey(K key) {
			this.key = key;
		}
		public V getValue() {
			return value;
		}
		public void setValue(V value) {
			this.value = value;
		}
		
		@Override
		public boolean equals(Object obj) {
			if(obj == this)
				return true;
			if(obj instanceof Node) {
				Node objRepalce = (Node)obj;
				if(objRepalce.key.equals(this.key) && objRepalce.value.equals(this.value)) {
					return true;
				}
			}
			return false;
		}
		
//		@Override
//		public int hashCode() {
//			return Objects.hashCode(key) ^ Objects.hashCode(value);
//		}
	}
	
	
	public static void main(String[] args) {
		MyHashMap hs = new MyHashMap();
		hs.put(" ", "123");
		hs.put("aaa", "aaa");
		hs.put("hhh", "bbb");  
		hs.put("add", "bbb");  
		hs.put("put", "bbb");   
		hs.put("hello", "bbb");  
		hs.put("777", "bbb");  
		hs.put("2f5d", "ccc");
		hs.put("38", "bbb");  
		System.out.println(hs.get(" "));
		

		
	}
}