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時需要特殊處理，為簡化實現忽略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);
            }
        }

        private 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]);
                    newTable[index] = old;
                    old = next;
                }
            }
            //用newTable替table
            table = newTable;
            //修改臨界值
            threshold = (int) (table.length * DEFAULT_LOAD_FACTOR);
            resize++;
        }

        public Object get(Object key) {
            //這裡簡化處理，忽略null值
            if (key == null) return null;
            HashEntry entry = getEntry(key);
            return entry == null ? null : entry.getValue();
        }

        public 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());
                    //如果成功找到並刪除，修改size
                    size--;
                    return;
                }
                pre = entry;
                entry = entry.getNext();
            }
        }

        public boolean containsKey(Object key) {
            if (key == null) return false;
            return getEntry(key) != null;
        }

        public int size() {
            return this.size;
        }

        public void clear() {
            for (int i = 0; i < table.length; i++) {
                table[i] = null;
            }
            this.size = 0;
        }


        @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 final 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 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;
        }
}