HashMap集合是Map介面的實現類，在Map集合不同於Collectiion集合，Map集合存放的是鍵值對，通過鍵(key)可以找到對應的值（value），而且每一個key是唯一的。那麼該如何自定義實現HashMap呢？

通過閱讀jdk的原始碼，發現HashMap的底層資料結構其實就是陣列加上鍊表。筆者通過閱讀原始碼，自定義實現了HashMap。

數組裡面存放的是連結串列LinkedList，而連結串列裡存放的是Entry(表示一對鍵值對)。首先通過key的hash值計算一個出一個數值，把它當做陣列的索引(index)，如果有兩個key計算得到的index相同，則這兩對鍵值對存放在索引為index的LinkedList當中。如果兩個key計算得到的index不同，這這兩個鍵值對會存放在不同的LinkedList當中。如圖：

具體的程式碼實現如下：

package com.tiantang.collection;

/**
 * 自定義的Map集合介面
 * @author LiuJinkun
 *
 */
public interface MyMap {
	/**
	 * 返回集合的大小
	 * @return
	 */
	int size();
	
	/**
	 * 存放鍵值對
	 * @param key
	 * @param value
	 */
	void put(Object key,Object value);
	
	/**
	 * 根據鍵查詢值
	 * @param key
	 * @return
	 */
	Object get(Object key);
	
	/**
	 * 判斷集合是否為空
	 * @return
	 */
	boolean isEmpty();
	
	/**
	 * 移除鍵所對應的鍵值對
	 * @param key
	 */
	void remove(Object key);
	
	/**
	 * 集合中是否包含指定的key
	 * @param key
	 * @return
	 */
	boolean containsKey(Object key);
	
	/**
	 * 集合中是否包含指定的value值
	 * @param value
	 * @return
	 */
	boolean containsValue(Object value);

}
 

package com.tiantang.collection;

import java.util.LinkedList;

/**
 * 自定義的HashMap
 * 
 * @author LiuJinkun
 *
 */
public class MyHashMap implements MyMap {

	private int size;

	// 用來存放LinkedList的陣列（陣列的下標用key所對應的hash值進行相應的計算而得到）
	private LinkedList<Entry>[] arr;

	/**
	 * 無參構造器，預設初始化陣列容量為16 事實上，這裡陣列的初始化大小隻要求大於0即可，但過大會佔用太多的記憶體，過小則會影響查詢的效能
	 * 因此這裡根據參照原始碼，使其初始化大小為16（jdk原始碼根據負載均衡量會重新該表陣列的大小，這裡筆者簡單的實現，沒有考慮那麼詳細）
	 */
	public MyHashMap() {
		// 預設初始化陣列容量為16
		this(16);
	}

	/**
	 * 有參構造器
	 * 
	 * @param initialCapacity
	 */
	public MyHashMap(int initialCapacity) {
		if (initialCapacity <= 0) {
			throw new IllegalArgumentException();
		} else {
			this.arr = new LinkedList[initialCapacity];
		}
	}

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

	@Override
	public void put(Object key, Object value) {
		Entry entry = new Entry(key, value);

		int index = getIndex(key);
		if (arr[index] == null) {
			LinkedList<Entry> list = new LinkedList<Entry>();
			list.add(entry);
			arr[index] = list;
			size++;
		} else {
			// 然後判斷key是否重複
			for (int i = 0; i < arr[index].size(); i++) {
				//如果與集合中的key重複的就替換掉原來的value值
				if (arr[index].get(i).getKey().equals(key)) {
					arr[index].get(i).value=value;
					return;
				}
			}
			//如果不重複，就新增
			arr[index].add(entry);
			size++;
		}
	}

	@Override
	public Object get(Object key) {
		int index = getIndex(key);
		//獲得該索引處存放的連結串列
		LinkedList<Entry> list=arr[index];
		
		if(list!=null){
			//遍歷連結串列，若果key相等就返回對應的value
			for(int i=0;i<list.size();i++){
				if(list.get(i).key.equals(key)){
					return  list.get(i).value;
				}
			}
		}
		return null;
	}

	@Override
	public boolean isEmpty() {
		return size==0;
	}

	@Override
	public void remove(Object key) {
		int index = getIndex(key);
		LinkedList<Entry> list=arr[index];
		if(list!=null){
			for(int i=0;i<list.size();i++){
				if(list.get(i).key.equals(key)){
					list.remove(i);
					size--;
					return;
				}
			}
		}
	}

	@Override
	public boolean containsKey(Object key) {
		//根據key得到索引
		int index = getIndex(key);
		LinkedList<Entry> list=arr[index];
		if(list!=null){
			for(int i=0;i<list.size();i++){
				if(list.get(i).key.equals(key)){
					return true;
				}
			}
		}
		return false;
	}

	/**
	 * 根據key的hash值然後通過計算得到陣列索引
	 * 演算法為：hash值除以arr陣列的長度（這樣保證了得到的陣列索引是有效的）
	 * @param key
	 * @return
	 */
	private int getIndex(Object key) {
		int index=key.hashCode()%arr.length;
		return index;
	}

	@Override
	public boolean containsValue(Object value) {
		for(int i=0;i<arr.length;i++){
			if(arr[i]!=null){
				for(int j=0;j<arr[i].size();j++){
					if(arr[i].get(j).value.equals(value)){
						return true;
					}
				}
			}
		}
		return false;
	}

	private class Entry {
		
		Object key;
		Object value;

		public Object getKey() {
			return key;
		}

		public Object getValue() {
			return value;
		}

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

	}

}
 

上述程式碼只是簡單實現了Map裡面的部分方法，而且程式碼還可以在很大程度上優化，讀者如果有興趣可以自行研究。

下面是筆者又優化了部分程式碼後的結果：

package com.tiantang.collection;

import java.util.LinkedList;

/**
 * 自定義的HashMap
 * 
 * @author LiuJinkun
 *
 */
public class MyHashMap implements MyMap {

	private int size;

	// 用來存放LinkedList的陣列（陣列的下標用key所對應的hash值進行相應的計算而得到）
	private LinkedList<Entry>[] arr;

	/**
	 * 無參構造器，預設初始化陣列容量為16 事實上，這裡陣列的初始化大小隻要求大於0即可，但過大會佔用太多的記憶體，過小則會影響查詢的效能
	 * 因此這裡根據參照原始碼，使其初始化大小為16（jdk原始碼根據負載均衡量會重新該表陣列的大小，這裡筆者簡單的實現，沒有考慮那麼詳細）
	 */
	public MyHashMap() {
		// 預設初始化陣列容量為16
		this(16);
	}

	/**
	 * 有參構造器
	 * 
	 * @param initialCapacity
	 */
	public MyHashMap(int initialCapacity) {
		if (initialCapacity <= 0) {
			throw new IllegalArgumentException();
		} else {
			this.arr = new LinkedList[initialCapacity];
		}
	}

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

	@Override
	public void put(Object key, Object value) {
		Entry entry = new Entry(key, value);

		int index = getIndex(key);
		if (arr[index] == null) {
			LinkedList<Entry> list = new LinkedList<Entry>();
			list.add(entry);
			arr[index] = list;
			size++;
		} else {
			// 然後判斷key是否重複
			for (int i = 0; i < arr[index].size(); i++) {
				//如果與集合中的key重複的就替換掉原來的value值
				if (arr[index].get(i).getKey().equals(key)) {
					arr[index].get(i).value=value;
					return;
				}
			}
			//如果不重複，就新增
			arr[index].add(entry);
			size++;
		}
	}

	@Override
	public Object get(Object key) {
		int index = getIndex(key);
		//獲得該索引處存放的連結串列
		LinkedList<Entry> list=arr[index];
		
		int i=getIndexOfNode(key, list);
		if(i!=-1){
			return list.get(i).value;
		}
		
		return null;
	}

	@Override
	public boolean isEmpty() {
		return size==0;
	}

	@Override
	public void remove(Object key) {
		int index = getIndex(key);
		LinkedList<Entry> list=arr[index];
		int i=getIndexOfNode(key, list);
		if(i!=-1){
			list.remove(i);
		}
		
	}
	
	/**
	 * 根據key的hash值然後通過計算得到陣列索引
	 * 演算法為：hash值除以arr陣列的長度（這樣保證了得到的陣列索引是有效的）
	 * @param key
	 * @return
	 */
	private int getIndexOfNode(Object key,LinkedList<Entry> list){
		if(list!=null){
			for(int i=0;i<list.size();i++){
				if(list.get(i).key.equals(key)){
					return i;
				}
			}
		}
		return -1;
	}
	
	private int getIndex(Object key){
		return key.hashCode()%arr.length;
	}

	@Override
	public boolean containsKey(Object key) {
		int index=getIndex(key);
		return getIndexOfNode(key,arr[index])!=-1;
	}

	@Override
	public boolean containsValue(Object value) {
		for(int i=0;i<arr.length;i++){
			if(arr[i]!=null){
				for(int j=0;j<arr[i].size();j++){
					if(arr[i].get(j).value.equals(value)){
						return true;
					}
				}
			}
		}
		return false;
	}

	private class Entry {
		
		Object key;
		Object value;

		public Object getKey() {
			return key;
		}

		public Object getValue() {
			return value;
		}

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

	}

}