标签：HashMap int entry Entry 手写 null table public

摘自

• 考虑了：put get resize hash

1.定义接口

public interface MyMap<K, V> {

    public V put(K k, V v);
    public V get(K k);

    interface Entry<K, V>{
        public K getKey();
        public V getValue();
    }
}

2. 主要部分

import java.util.ArrayList;
import java.util.List;

public class MyHashMap<K,V> implements MyMap<K,V>{
    //数组的默认初始化长度
    private static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
    //阈值比例
    private static final float DEFAULT_LOAD_FACTOR = 0.75f;

    private int defaultInitSize;
    private float defaultLoadFactor;
    //Map中Entry的数量
    private int entryUserSize;
    //数组
    private Entry<K,V>[] table = null;

    //MyHashMap的构造
    public MyHashMap() {
        this.defaultLoadFactor = DEFAULT_LOAD_FACTOR;
        this.defaultInitSize = DEFAULT_INITIAL_CAPACITY;
        table = new Entry[this.defaultInitSize];
    }

    public MyHashMap(int defaultInitSize, int defaultLoadFactor){
        /*if(defaultLoadFactor < 0){
            throw new IllegalArgumentException("Illegal initial capacity:" + defaultInitSize);
        }
        if(defaultLoadFactor <= 0 || Float.isNaN((defaultLoadFactor))){
            throw new IllegalArgumentException("Illegal load factor:"+ defaultLoadFactor);
        }*/

        this.defaultInitSize = defaultInitSize;
        this.defaultLoadFactor = defaultLoadFactor;
        table = new Entry[this.defaultInitSize];
    }

    class Entry<K,V> implements MyMap.Entry<K,V>{//内部类
        private K key;
        private V value;
        private Entry<K,V> next;

        public Entry(){ }

        public Entry(K key, V value, Entry<K,V> next){
            this.key = key;
            this.value = value;
            this.next = next;
        }

        @Override
        public K getKey() {
            return key;
        }

        @Override
        public V getValue() {
            return value;
        }
    }

    @Override
    public V put(K k, V v) {
        V oldValue = null;
        //是否需要扩容
        //扩容完毕 肯定要重新散列
        if(entryUserSize >= defaultInitSize * defaultLoadFactor){
            resize(2 * defaultInitSize);
        }
        //得到Hash值,计算出数组中的位置
        int index = hash(k) & (defaultInitSize-1);
        if(table[index] == null){
            table[index] = new Entry<K,V>(k,v,null);
            ++entryUserSize;
        }else{//需要遍历单链表
            Entry<K,V> entry = table[index];
            Entry<K,V> e = entry;
            while(e != null){
                if(k == e.getKey() || k.equals(e.getKey())){
                    oldValue = e.value;
                    e.value = v;
                    return oldValue;//更新完返回
                }
                e = e.next;
            }
            table[index] = new Entry<K,V>(k,v,entry);//头插法
            ++entryUserSize;
        }
        return oldValue;
    }

    private int hash(K k){
        int h;
        return (k == null) ? 0 : Math.abs(h = k.hashCode()) ^ (h >>> 16);
    }

    private void resize(int i){
        Entry[] newTable = new Entry[i];
        defaultInitSize = i;
        entryUserSize = 0;
        rehash(newTable);
    }

    private void rehash(Entry<K,V>[] newTable){
        //得到了原来老的Entry集合  注意遍历单链表
        List<Entry<K,V>> entryList = new ArrayList<>();
        for(Entry<K,V> entry : table){
            if(entry != null){
                while(entry != null){
                    entryList.add(entry);
                    entry = entry.next;
                }
            }
        }

        //覆盖旧的引用
        if(newTable.length > 0){
            table = newTable;
        }

        //所谓重新Hash,就是重新put Entry到HashMap
        for(Entry<K,V> entry : entryList){
            put(entry.getKey(), entry.getValue());
        }
    }

    @Override
    public V get(K k) {
        int index = hash(k) & (defaultInitSize-1);

        if(table[index] == null){
            return null;
        }else{
            Entry<K,V> entry =  table[index];
            while(entry != null){
                if(k == entry.getKey() || k.equals(entry.getKey())){
                    return entry.getValue();
                }
                entry = entry.next;
            }
        }
        return null;
    }
}

3. 测试部分

public class Test {
    public static void main(String[] args) {

        MyMap<String,String> myMap = new MyHashMap<>();

        for(int i = 0; i < 200; i++){
            myMap.put("key"+i,"value"+i);
        }

        for(int i = 0; i < 200; i++){
            System.out.println("key"+i+"value is : " + myMap.get("key"+i));
        }
    }
}

标签：HashMap,int,entry,Entry,手写,null,table,public
来源： https://blog.csdn.net/weixin_42605958/article/details/120754271

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。