java---简单hashMap实现

1、什么是hash？,什么是hash表？
　　hashmap jdk起到了一个以点概面的作用
1、什么是hash
它是将一个任意长度的二进制值通过一个映射关系转换成一个固定长度的二进制值
　　1、任意长度的二进制值
　　2、映射关系(哈希算法--就相当于一个大学里面的学号的一个映射规则）
　　3、固定的二进制值(哈希值--相当于我们的大学里面的学号)
　　任意长度的二进制值和固定长度的二进制值是一个一一对应关
　　固定长度的二进制值就相当于一个任意长度的二进制值的一个摘要
　　因定长度的二进制值相当于一个关键字key
　　真正有效的数据就是这个学员的基本信息，一个任意长度的二进制值value

key ----- value
hash只是确定了一个key和一个value的唯一映射关系,
为什么要这么做:
2. hashtable
　　特点:最重要的特点----它存储效率很高,取数据的时间复杂度是1  o(1)
　　hash通过一个key一个输入,通过一个哈希函数,来找到数组中与这个key唯一映射的value
　　根据这个haah函数找到数组中这个value的下标

3.哈希函数

　　key,找下标，方法？

　　1、取模

　　int index = key%m;

　　m的取值规则：

　　　　m要取比数组长度小的最大质数

4.hash表处理冲突

　　1、线性探测法：探测步长为1；

　　2、链表形式

 哈希表存储规则：

优缺点：

优点：时间复杂度o(1),存取速度快

缺点：无序，耗内存存放key，空间换取时间

实现代码：

package com.jove;

public class DNHashMap<V, K> implements DNMap<K, V> {
    /**
     * 哈希表默认长度
     */
    private static Integer defaultLength = 16;
    
    /**
     * 负载因子   当数组存放的数据达到defaultLength*defaultLoad就进行扩容
     */
    private static double defaultLoad = 0.75;

    /**
     * 键值对数组
     */
    private Entry<K, V>[] table = null;
    
    private int size = 0;

    public DNHashMap(int defaultLength, double defaultLoad) {
        this.defaultLength = DNHashMap.defaultLength;
        this.defaultLoad = DNHashMap.defaultLoad;
        table = new Entry[defaultLength];
    }

    public DNHashMap() {
        this(defaultLength, defaultLoad);
    }

    public V put(K k, V v) {
        int index = this.getIndex(k);
        Entry<K, V> e = table[index];
        if(e == null){
            table[index]= new Entry(k,v,index,null);  
        }else{
            Entry entry = new Entry(k,v,index,e);
            table[index] = entry;
        }
        return table[index].getValue();
    }

    public V get(K k) {
        int index = this.getIndex(k);
        
        return table[index] == null ? null:table[index].getValue();
    }

    public int size() {
        return size;
    }

    /**
     * 通过哈希算法之后获得键的索引号
     * @param key
     * @return
     */
    public int getIndex(K key) {
        int m = defaultLength - 1;
        return key.hashCode() % m;
    }

    /**
     * 内部类  Entry 用链表的形式存储entry
     * @author jove
     *
     * @param <K> key
     * @param <V> value
     */
    class Entry<K, V> implements DNMap.Entry<K, V> {
        private K key;
        private V value;
        private int index;
        private Entry<K, V> next;

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

        public K getKey() {
            return key;
        }

        public V getValue() {
            return value;
        }

    }
}

package com.jove;

public interface DNMap<K,V> {
    V put(K k,V v);
    
    V get(K k);
    
    int size();
    
    interface Entry<K,V>{
        K getKey();
        
        V getValue();
    }
}

测试代码：

package com.jove;

public class MapTest {
    public static void main(String[] args) {
        DNHashMap<Object,Object> map = new DNHashMap<>();
        map.put("hh", "j0ee");
        map.put("jj", "jove");
        
        System.out.println(map.get("hh"));
        System.out.println(map.get("jj"));
    }
}