手动实现HashMap集合

/*
* 实现HashMap集合
* put(key,value)
* 1)key-> hash 散列码
* 2)hash& table.length-1 ->index
* 3)if(table[index]==null{
* 直接放
* }else{
* 找key是否存在，如果存在，新值覆盖旧值
* 如果不存在，将key,value封装为一个结点Entry直接添加
*
* }
* */
class MyHashMap<K,V>{
    private  Entry<K,V>[] table;//桶 用来放节点
    private int size;//记录当前节点个数
    private  static final int defaultCapacity=8;

    @Override
    public String toString() {
        return "MyHashMap{" +
                "table=" + Arrays.toString(table) +
                '}';
    }

    class Entry<K,V>{
        private K key;
        private V value;
        protected Entry<K,V> next;
        protected int hash;

        public Entry(K key, V value, int hash) {
            this.key = key;
            this.value = value;
            this.hash = hash;
        }

        @Override
        public String toString() {
            return "Entry{" +
                    "key=" + key +
                    ", value=" + value +
                    ", hash=" + hash +
                    '}';
        }
    }
    public MyHashMap(){
        this(defaultCapacity);
    }
    public MyHashMap(int capacity){
        table=new Entry[capacity];
    }
    public int hash(K key){
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
    public void put(K key,V value){
        int hash=hash(key);//计算散列值
        int index=hash & table.length-1;//获取数组下标
        if(table[index]==null){
            //将key/value封装为一个Entry节点直接放在该位置
            table[index]=new Entry<>(key, value, hash);
            size++;
        }else{
          Entry<K,V> firstNode= table[index];
          //查找是否有重复key
            if(firstNode.key.equals(key)){
                //该key存在于该位置的第一个节点//值覆盖
                firstNode.value=value;
            }else{
                //遍历链表
                 Entry<K,V> currentNode=firstNode;
               while(currentNode.next!=null&&!currentNode.key.equals(key)){
                    currentNode=currentNode.next;
                }
                if(currentNode.next==null){
                    //仅剩最后一个元素没有判断
                    if(currentNode.key.equals(key)){
                        currentNode.value=value;
                    }else{
                        currentNode.next= new Entry<>(key,value,hash);
                        size++;
                    }

                }else{
                 //  currentNode.next!=null&&currentNode.key.equals(key)
                   currentNode.value =value;
                }

            }


        }

    }
    public V get(K key){
        //确定散列码
        int hash=hash(key);
        //确定索引位置
        int index=hash&table.length-1;
        Entry<K,V> firstNode=table[index];
        if(firstNode==null){
            return null;
        }else{
            //遍历列表
            Entry<K,V> currentNode=firstNode;
            while(currentNode!=null){
                if (currentNode.key.equals(key)){
                    return currentNode.value;
                }
                currentNode=currentNode.next;
            }
        }

      return null;

    }
    //移除key所在的entry节点
    public boolean remove(K key){
        int hash=hash(key);
        int index=hash &table.length-1;
        Entry<K,V> firstNode=table[index];
        if(firstNode==null){
            //说明该位置没有元素
            return false;
        }else{
            if(firstNode.key.equals(key)){
                table[index]=firstNode.next;//赋值
                return true;
            }
            //firstNode作为当前节点的前一个
            while(firstNode.next!=null){//只要用到的引用，都要判断它不为空
               if(firstNode.next.key.equals(key)){
                   firstNode.next=firstNode.next.next;
                   return true;
               }else{
                   firstNode=firstNode.next;
               }
            }

            }
            return false;
        }

    }


public class HashMapTest {
    public static void main(String[] args) {
        MyHashMap<String, Integer>  map = new MyHashMap<>();
        map.put("dandan",23);
        map.put("xuanxuan",56);
        map.put("mengchen",12);
        System.out.println(map);
        System.out.println(map.get("dandan"));
        System.out.println(map.remove("dandan"));
        System.out.println(map);

    }
}

标签：hash,HashMap,手动,value,key,firstNode,集合,currentNode,table
来源： https://blog.csdn.net/weixin_49263647/article/details/115801543