自己实现一个简单的hashmap

这个hashmap实现方式应该是jdk1.7的,在数据量小的时候和jdk1.8实现的差不多,不过我这个没有采用链表长度8时转化红黑树增加查询效率,在扩容时也是全部元素重新hash,计算新的位置,

所以如果大数据量的时候,复制到新的数组就会比较慢.,jdk8里面对复制到新的数组也是有优化的,我这里就没做了.

package com.tqq;

/**
 * @Description: 自己实现简易hashmap,只有put和get,会自动扩容,没有链表达到长度转红黑树
 * @Author: Tan
 * @CreateDate: 2020/3/15
 **/
public class MyHashMap<K,V> {

    //节点数组 用于存放所有节点
    Node[] NodeArray;
    //节点数组默认大小
    int defaultSize=16;

    int NodeCount=0;

    //链表
    class Node<K,V> {
        int hash;
        K  key;
        V  value;
        Node nextNode;
        public Node(int hash, K key, V value, Node nextNode) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.nextNode = nextNode;
        }

        public Node() {
        }
    }



    public V put(K key,V value){
        V returnValue=null;
        if(NodeArray==null){
            NodeArray=new Node[defaultSize];
        }
        //得到当前key存放于节点数组中的索引
        int nodeArrayIndex=(key.hashCode())%NodeArray.length;

        nodeArrayIndex=Math.abs(nodeArrayIndex);
        Node indexNode=NodeArray[nodeArrayIndex];
        if(indexNode==null){
            NodeArray[nodeArrayIndex]=new Node(key.hashCode(),key,value,null);
            returnValue=value;
        }else{
            Node next=indexNode;
            while (true){
                if(key.equals(next.key)){
                    next.value=value;
                    next.hash=key.hashCode();
                    returnValue=value;
                    break;
                }
                if(next.nextNode==null){
                    next.nextNode=new Node(key.hashCode(),key,value,null);
                    returnValue=value;
                    break;
                }
                next=next.nextNode;
              }
            }
       NodeCount++;
        resize();
        return returnValue;
    }


    public V get(K key){
        //得到当前key存放于节点数组中的索引
        int nodeArrayIndex=(key.hashCode())%defaultSize;
        if (NodeArray!=null){
           Node indexNode= NodeArray[nodeArrayIndex];
           if(indexNode.hash==key.hashCode()&&key==indexNode.key){
               return  (V) indexNode.value;
           }
            while ((indexNode=indexNode.nextNode)!=null){
                if(indexNode.hash==key.hashCode()&&key==indexNode.key){
                    return  (V) indexNode.value;
                }
            }
        }
        return  null;
    }


    public void resize(){
        if(NodeCount>=NodeArray.length*0.75){
            Node[] newNodeArray=new Node[NodeArray.length*2];
            for (int i = 0; i < NodeArray.length; i++) {
                if(NodeArray[i]!=null){
                    NodeMove(NodeArray[i],newNodeArray);
                    while (NodeArray[i].nextNode!=null){
                        NodeMove(NodeArray[i].nextNode,newNodeArray);
                        NodeArray[i]=NodeArray[i].nextNode;
                    }
                }
            }
            NodeArray=newNodeArray;
        }
    }

    //移动
    public void NodeMove(Node node,Node[] newNodeArray){
        int nodeArrayIndex=Math.abs((node.key.hashCode())%newNodeArray.length);
        if(newNodeArray[nodeArrayIndex]==null){
            newNodeArray[nodeArrayIndex]=node;
        }else{
            Node next=newNodeArray[nodeArrayIndex];
            while (true){
                if(node.key.equals(next.key)){
                    next.value=node.value;
                    next.hash=node.key.hashCode();
                    break;
                }
                if(next.nextNode==null){
                    next.nextNode=new Node(node.hashCode(),node.key,node.value,null);
                    break;
                }
                next=next.nextNode;
            }
        }
    }


}