手写HashMap(链表+数组)

手写HashMap

package HashMap;

/**
 * @author ma
 * @date 2022/1/24
 */
public class MyHashMap<K, V> {
    class Node<K, V>{
        //键值对
        private K key;
        private V value;
        //链表、后继
        private Node<K, V> next;
        public Node(K key, V value){
            this.key = key;
            this.value = value;
        }
        public Node(K key, V value, Node<K, V> next){
            this.key = key;
            this.value = value;
            this.next = next;
        }
    }
    //默认容量
    final int DEFAULT_CAPACITY = 16;
    //负载因子
    final  float LOAD_FACTOR = 0.75f;
    //大小
    private int size;
    //桶数组
    Node<K, V>[] buckets;
    //无参构造器，设置桶数组默认容量
    public MyHashMap(){
        buckets = new Node[DEFAULT_CAPACITY];
        size = 0;
    }
    //有参构造器，指定桶数组的容量
    public MyHashMap(int capacity){
        buckets = new Node[capacity];
        size = 0;
    }
    //哈希函数，获取数组的索引值
    private int getIndex(K key, int length){
        int hashCode = key.hashCode();
        int index = hashCode % length;
        return Math.abs(index);
    }
    //put方法
    public void put(K key, V value){
        if(size >= buckets.length * LOAD_FACTOR) resize();
        putVal(key, value, buckets);
    }
    //将元素存入
    private void putVal(K key, V value, Node<K, V>[] table){
        int index = getIndex(key, table.length);
        Node node = table[index];
        //插入的位置为空
        if(node == null){
            table[index] = new Node<>(key, value);
            size++;
            return;
        }
        while (node != null){
            //如果相同，就覆盖
            if((node.key.hashCode() == key.hashCode()) && (node.key == key || node.key.equals(key))){
                node.value = value;
                return;
            }
            node = node.next;
        }
        //当前key不在链表中，插入链表头部
        Node newNode = new Node(key, value, table[index]);
        table[index] = newNode;
        size++;
    }
    //扩容
    private void resize(){
        //创建一个容量为2倍的新数组
        Node<K, V>[] newBuckets = new Node[buckets.length * 2];
        rehash(newBuckets);
        buckets =newBuckets;
    }
    //重新散列当前元素
    private void rehash(Node<K, V>[] newBuckets){
        size = 0;
        for(int i=0; i<buckets.length; i++){
            if(buckets[i] == null){
                continue;
            }
            Node<K, V> node = buckets[i];
            while(node != null){
                putVal(node.key, node.value, newBuckets);
                node = node.next;
            }
        }
    }
    public V get(K key){
        int index = getIndex(key, buckets.length);
        if(buckets[index] == null) return null;
        Node<K, V> node = buckets[index];
        while(node!=null){
            if((node.key.hashCode() == key.hashCode()) && (node.key == key || node.key.equals(key))){
                return node.value;
            }
            node = node.next;
        }
        return null;
    }
    public int size(){
        return size;
    }

    public static void main(String[] args) {
        MyHashMap map = new MyHashMap();
        map.put(1,"小");
        map.put(2,"ma");
        System.out.println(map.get(1));
        System.out.println(map.size());
    }
}