哈希算法与HashMap

哈希算法

Hash，是把任意长度的输入（又叫做预映射pre-image）通过散列算法变换成固定长度的输出，该输出就是散列值

哈希算法特点

• 正向快速：给定明文和 hash 算法，在有限时间和有限资源内能计算出 hash 值。
• 逆向困难：给定（若干） hash 值，在有限时间内很难（基本不可能）逆推出明文。
• 输入敏感：原始输入信息修改一点信息，产生的 hash 值看起来应该都有很大不同。
• 冲突避免：很难找到两段内容不同的明文，使得它们的 hash 值一致（发生冲突）。即对于任意两个不同的数据块，其hash值相同的可能性极小；对于一个给定的数据块，找到和它hash值相同的数据块极为困难。

HashMap 实现

import java.util.Objects;

public class MyHashMap {
    
    
    //MyHashMap 结构为数组 + 单向链表

    private Entry[] table = null;

    private Integer tableDefaultLength = 8;

    class Entry<K, V>{
    
    
        private K k;
        private V v;
        private Entry next;//单向链表指针，指向下一个节点

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

    public String put(String k, String v){
    
    
        if (Objects.isNull(table)){
    
    
            //初始化数组长度
            initTable();
        }
        //根据 key 获取对应的 hashCode
        int hashCode = k.hashCode();

        //根据 hashCode 获取数组对应的下标
        int index = getIndex(hashCode);

        //判断对应坐标是否存在链表
        if (Objects.nonNull(table[index])){
    
    
            //便利链表，查找 key 值是否已经存在
            for (Entry entry = table[index]; entry != null; entry = entry.next){
    
    
                if (entry.k.equals(k)){
    
    
                    //key 值存在，返回原始值，替换为新值
                    Object o = entry.v;
                    entry.v = v;
                    return (String) o;
                }
            }
        }

        //代码进行到这里，说明key值不重复，将此对象插入链表头部
        //remark：为什么要插入链表头部呢，因为 Map 对应坐标放的就是链表的头部节点，
        //直接将新节点替换此头部节点，作为新的头部节点，然后新的头部节点的下一个节点
        //指向原来旧的头部节点，做出的更改相对较少

        //1：获取头部节点
        Entry headEntry = table[index];
        //2：创建新的头部节点并把next 指向原来的头部节点
        Entry headEntryNew =  new Entry(k ,v , headEntry);
        //3：将头部节点放入数组对应下标
        table[index] = headEntryNew;

        return null;
    }

    public String get(String k){
    
    
        //根据 key 获取对应的 hashCode
        int hashCode = k.hashCode();

        //根据 hashCode 获取数组对应的下标
        int index = getIndex(hashCode);

        //判断对应坐标是否存在链表
        if (Objects.nonNull(table[index])){
    
    
            //便利链表，查找 key 值是否已经存在
            for (Entry entry = table[index]; entry != null; entry = entry.next){
    
    
                if (entry.k.equals(k)){
    
    
                    return (String) entry.v;
                }
            }
        }
        return null;
    }

    private int getIndex(int hashCode) {
    
    
        //目前先使用对数组长度取 %
        return hashCode % tableDefaultLength;
    }

    private void initTable() {
    
    
        table = new Entry[tableDefaultLength];
    }


    public static void main(String[] args) {
    
    
//        HashMap<Object, Object> objectObjectHashMap = new HashMap<>();
//        objectObjectHashMap.put("k", "v");
        MyHashMap map = new MyHashMap();
        System.out.println(map.put("1", "1value"));
        System.out.println(map.put("2", "2value"));
        System.out.println(map.put("1", "1.1value"));

        System.out.println(map.get("1"));
        System.out.println(map.get("2"));

    }
}