自己实现一个简单版的HashMap

自己实现一个简单版的HashMap

http://blog.csdn.net/uhgagnu/article/details/60144735

package com.skex.map;

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

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyHashMap map = new MyHashMap();
        map.put("100",100);
        map.put("abc",10000);
/*
size:2 capacity:16 resize:0

100:100
abc:10000

----------------------------
*/
        System.out.println(map);//
        System.out.println("----------------------------");
/*
10000
---------------------------- 
*/
        System.out.println(map.get("abc"));//
        System.out.println("----------------------------");

/*
40
----------------------------
*/        
        map.put("abc",40);
        System.out.println(map.get("abc"));//
        System.out.println("----------------------------");
        
/*
size:3 capacity:16 resize:0

001:1
100:100
abc:40

---------------------------- 
*/        
        map.put("001",1);
        System.out.println(map);//
        System.out.println("----------------------------");

/*
size:1 capacity:16 resize:0

222:2

---------------------------- 
*/        
        MyHashMap map2 = new MyHashMap();
        map2.put("222",2);
        System.out.println(map2);//
        System.out.println("----------------------------");
/*
1
---------------------------- 
*/        
        System.out.println(map2.size());//
        System.out.println("----------------------------");     

    }

}