java仿写HashMap

实现Map接口的类用来存储（key）-值（value）对
Map接口的实现类有HashMap和TreeMap等。
Map类中存储的键-值对通过键来标识，所以键值不能重复。

HashMap效率高，线程不安全
Hashtable 效率低，线程安全

Map底层实现：数组+链表

为深入了解学习HashMap，自己仿写了部分方法。

不完美，for影响效率

/** 
 *  
 * Map:存放键值对，根据键对象找对应的值对象，键不能重复 
 * 
 */  
public class MyHashMap {  
    private MyEntry[] arr = new MyEntry[999];  
    private int size;  
  
    public int size() {  
        return this.size;  
    }  
  
    //添加
    public void put(Object key, Object value) {  
        MyEntry entry = new MyEntry(key, value);  
        // 键值重复处理，直接覆盖  
        for (int i = 0; i < size; i++) {  
            if (arr[i].key.equals(key)) {  
                arr[i].value = value;  
                return;  
            }  
        }  
        arr[size++] = entry;  
    }  
  
    //根据键获取对应的值
    public Object get(Object key) {  
        for (int i = 0; i < size; i++) {  
            if (arr[i].key.equals(key)) {  
                return arr[i].value;  
            }  
        }  
        return null;  
    }  
  
    //判断是否存在该键
    public boolean containsKey(Object key) {  
        for (int i = 0; i < size; i++) {  
            if (arr[i].key.equals(key)) {  
                return true;  
            }  
        }  
        return false;  
    }  
  
    //判断是否存在该值
    public boolean containsValue(Object value) {  
        for (int i = 0; i < size; i++) {  
            if (arr[i].value.equals(value)) {  
                return true;  
            }  
        }  
  
        return false;  
    }  
}  
  
//仿写键值对
class MyEntry {  
    Object key;  
    Object value;  
  
    public MyEntry(Object key, Object value) {  
        super();  
        this.key = key;  
        this.value = value;  
    }  
}  

优化提示：

Map底层实现：数组+链表，每个对象都有对应的hashCode值，将hashCode取余，分区间片段进行存储，片段以链表的形式进行存储。

知识拓展：两个内容相同的对象应该具有相等的hashcodes,反之，则不然。

import java.util.LinkedList;

/**
 * 
 * Map:存放键值对，根据键对象找对应的值对象，键不能重复
 * Map底层实现：数组+链表，每个对象都有对应的hashCode值，将hashCode取余，分区间片段进行存储，片段以链表的形式进行存储
 * 知识拓展：两个内容相同的对象应该具有相等的hashcodes,反之，则不然。
 *
 */
public class MyHashMap {
	private LinkedList[] arr = new LinkedList[999];// Map底层实现：数组+链表
	private int size;

	public int size() {
		return this.size;
	}

	//插入
	public void put(Object key, Object value) {
		MyEntry e = new MyEntry(key, value);
		int hash = key.hashCode();
		hash = hash < 0 ? -hash : hash;//hashCode可能出现负值
		int a = hash % arr.length;
		if (arr[a] == null) {
			LinkedList list = new LinkedList();
			list.add(e);
			arr[a] = list;
		} else {
			LinkedList list = arr[a];
			for (int i = 0; i < list.size(); i++) {
				MyEntry myEntry = (MyEntry) list.get(i);
				if (myEntry.key.equals(key)) {
					myEntry.value = value;// 键值重复，直接覆盖
					return;
				}
			}
			arr[a].add(e);
		}

	}
}

//仿写键值对
class MyEntry {
	Object key;
	Object value;

	public MyEntry(Object key, Object value) {
		super();
		this.key = key;
		this.value = value;
	}
}

当然，这个只是仿写部分功能，有兴趣的可以继续深入研究