java实现一个简单的HashMap

1.定义HashMap初始化大小 HashEntry[];由多个HashEntry组成的数组
2.定义HashMap会进行扩容的阈值 负载因子
阈值 threshold = (int) (DEFAULT_INITIAL_CAPACITY*DEFAULT_LOAD_FACTOR);
3.定义hashMap中装载Entry的格式 size
Entry（key，value，next）
put操作：先找到key对应的Entry，再遍历Entry链表
remove操作：同上

package DataStruct;


/**
 * Description：HashMap实现<br/>
 * Copyright (c) ， 2019， LafreeZhao <br/>
 * This program is protected by copyright laws. <br/>
 * Date：2019年03月05日
 *
 * @author 赵炳泉
 * @version : 1.0
 */
public class MyHashMap {
    //默认初始化大小 16
    private static final int DEFAULT_INITIAL_CAPACITY = 16;
    //默认负载因子 0.75
    private static final float DEFAULT_LOAD_FACTOR = 0.75f;

    //临界值
    private int threshold;
    //元素个数
    private int size;

    //扩容次数
    private int resize;

    private HashEntry[] table;

    public MyHashMap() {
        table = new HashEntry[DEFAULT_INITIAL_CAPACITY];
        threshold = (int) (DEFAULT_INITIAL_CAPACITY*DEFAULT_LOAD_FACTOR);
        size =0 ;
    }
    private int index(Object key){
        //根据key的hashcode和table长度取模计算key在table中的位置
        return key.hashCode()%table.length;
    }

    public void put(Object key,Object value){
        //key为null时，简化处理
        if (key == null) {
            return;
        }
        int index = index(key);

        //遍历index位置上的entry，若找到重复的key则更新对应entry的值，然后返回
        HashEntry entry = table[index];
        while(entry != null){
            if (entry.getKey().hashCode() == key.hashCode() && entry.getKey() == key || entry.getKey().equals(key)){
                entry.setValue(value);
                return;
            }
            entry = entry.getNext();
        }
        //若index位置没有entry或者未找到重复的key，则将新key添加到table的index位置
        add(index,key,value);
    }

    private void add(int index, Object key, Object value) {
        //将新的entry放到table的index位置第一个，若原来有值则以链表形式存放
        HashEntry entry = new HashEntry(key,value,table[index]);
        table[index] = entry;
        //判断size是否达到临界值，若已达到则进行扩容，将table的capacicy翻倍
        if (size++ >=threshold){
            resize(table.length*2);
        }
    }
    public void resize(int capacity) {
        if (capacity <=table.length){
           return;
        }
        HashEntry[] newTable = new HashEntry[capacity];
        //遍历原table，将每个entry都重新计算hash放入newTable中
        for (int i=0;i<table.length;i++){
            HashEntry old = table[i];
            while(old !=null){
                HashEntry next = old.getNext();
                int index = index(old.getKey());
                old.setNext(newTable[index]);
                old = next;
            }
        }
        table = newTable;
        threshold = (int) (table.length*DEFAULT_LOAD_FACTOR);
        resize++;
    }

    public Object get (Object key){
        if (key == null){
            return null;
        }
        HashEntry entry = getEntry(key);
        return entry == null?null:entry.getValue();
    }

    private HashEntry getEntry(Object key) {
        HashEntry entry = table[index(key)];
        while(entry !=null){
            if (entry.getKey().hashCode() == key.hashCode() ||entry.getKey() == key || entry.getKey().equals(key)){
                return entry;
            }
            entry = entry.getNext();
        }
        return null;
    }
    public void remove(Object key){
        if (key == null){return;}
        int index=index(key);
        HashEntry pre = null;
        HashEntry entry = table[index];
        while(entry !=null){
            if (entry.getKey().hashCode() == key.hashCode() && (entry.getKey() == key || entry.getKey().equals(key))){
                if (pre == null){
                    table[index]=entry.getNext();
                }else pre.setNext(entry.getNext());
                //如果成功找到并且删除的haul
                size--;
                return;
            }
            pre = entry;
            entry = entry.getNext();
        }
    }
    public  boolean containsKey(Object key){
        if (key == null){
            return false;
        }
        return getEntry(key)!=null;

    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(String.format("size:%s capacity:%s resize:%s\n\n", size, table.length, resize));
        for (HashEntry entry : table) {
            while (entry != null) {
                sb.append(entry.getKey() + ":" + entry.getValue() + "\n");
                entry = entry.getNext();
            }
        }
        return sb.toString();
    }
    }

    class HashEntry{
        private  Object key;
        private Object value;
        private HashEntry next;

        public HashEntry(Object key, Object value, HashEntry next) {
            this.key = key;
            this.value = value;
            this.next = next;
        }

        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 HashEntry getNext() {
            return next;
        }

        public void setNext(HashEntry next) {
            this.next = next;
        }
    }
}