普歌-允异团队-手写HashMap

Map

/**
 * Map 里有
 * put方法
 * get方法
 * size方法
 * Entry
 * 存储泛型 k，v
 * @param <K>
 * @param <V>
 */
public interface Map<K,V> {
    
    
    public V put(K k,V v);// 传k,v
    public V get(K k);
    public int size();


    public interface Entry<K,V>{
    
    
        K getKey();    //返回当前的 v

        V getValue();    //返回当前的 v


    }
}

HashMap

/*
    实现hashMap
* */
public class HashMap<K,V> implements Map<K,V>{
    
    

    private Entry<K,V> table[] = null; // 存储对象（需要存储多个值，所以必须用对象来存）
    int size = 0;


    public HashMap() {
    
    
        table = new Entry[16];//2的四次方，hashMap默认大小
    }



    /**
     * 通过Key hash 算法hash
     * index 下标数组 当前下标对象
     * 判断当前对象是否为空 如空 直接存储
     * 不空 冲突 next链表
     * @param k
     * @param v
     * @return
     */

    @Override
    public V put(K k, V v) {
    
    
        int index = hash(k);//拿到位置，开始找对象
        Entry<K, V> entry = table[index];
        if (null == entry){
    
    
            table[index] = new Entry<>(k, v, index, null);//判断当前对象是否为空 如空 直接存储
            size++;//记录数组长度，扩容时有意义

        }else {
    
    
            table[index] = new Entry<>(k, v, index, entry);// 不空
        }


        return table[index].getValue();
    }

    private int hash(K k){
    
    
        int index = k.hashCode() % 16;
        return index >= 0 ? index : -index;//可能为负数，负负为正 或者 return Math.abs（index）

    }

    /**
     * 通过key 进行hash
     * index下标数组对象
     * 判断当前对象是否为空  如果为不空
     * 在判断是否相等 如果不等
     * 判断next是否为空 如果不为空
     * 在判断是否相等 直到相等或为空为止
     * 返回
     * @param k
     * @return
     */

    @Override
    public V get(K k) {
    
    
        if (size == 0){
    
    
            return null;

        }
        int index = hash(k);
        Entry<K, V> entry = findValue(table[index],k);// 如果为不空

        return entry == null?null:entry.getValue();
    }

    /**
     * 例  entry 取出下标4 节点
     * k 查询 对一
     * @return
     */
    private Entry<K,V> findValue(Entry<K,V> entry,K k){
    
    
        if (k.equals(entry.getKey()) || k == entry.getKey()){
    
    
            return entry;
        }else {
    
    
            if (entry.next != null){
    
    
                return findValue(entry.next,k);//递归法
            }
        }
        return null;
    }

    @Override
    public int size() {
    
    
        return size++;
    }

    class Entry<K,V> implements Map.Entry<K,V>{
    
    //存储对象，存储多个值
        K k;
        V v;
        int hash;
        Entry<K,V> next;

        public Entry(K k, V v, int hash, Entry<K, V> next) {
    
    
            this.k = k;
            this.v = v;
            this.hash = hash;
            this.next = next;
        }

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

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

测试

public class Test {
    
    
    public static void main(String[] args) {
    
    
        Map<String, String> map = new HashMap<>();
        map.put("MikeCat","我是MikeCat");
        map.put("和大佛","和大佛浮点数");
        System.out.println(map.get("MikeCat"));
        System.out.println(map.get("和大佛"));
    }
}

结果

---

• 作者：麦克猫Cat

• 本文版权归作者和CSDN共有，欢迎交流