java【模拟MAP的底层实现】

1.1数组我们无论是C、Java都会学过：

数组是一种连续存储线性结构，元素类型相同，大小相等

数组的优点：

存取速度快

数组的缺点：

事先必须知道数组的长度
插入删除元素很慢
空间通常是有限制的
需要大块连续的内存块
插入删除元素的效率很低

2.1链表说明

看完了数组，回到我们的链表：

链表是离散存储线性结构
n个节点离散分配，彼此通过指针相连，每个节点只有一个前驱节点，每个节点只有一个后续节点，首节点没有前驱节点，尾节点没有后续节点。

链表优点：

空间没有限制
插入删除元素很快
链表缺点：

读取速度很慢，复杂度是O(n)

这里重点不是说数组和单向链表的区别，目的是自己代码实现map存储，因此关于数组和链表见下面的博客：
https://www.cnblogs.com/Java3y/p/8664874.html

下面是源代码

package com.bjsxt;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;

public class MyMap {
	static int instiallSize=10;
	static Object[] arr=new Object[instiallSize];
	static int size=0;
	
	/****
	 * 
	
	* @Title: addEntry
	
	* @Description: TODO(这里用一句话描述这个方法的作用)
	
	* @param @param key
	* @param @param value    设定文件
	
	* @return void    返回类型
	
	* @throws
	 */
	public static void addEntry(String key,String value){
		if(StringUtils.isEmpty(value.toString())){
			return;
		}
		SxtEntry x=new SxtEntry(key,value);
		if(arr.length==size){//扩容
			arr=Arrays.copyOf(arr, arr.length+instiallSize);	
			System.out.println("扩容成功，数组大小为"+arr.length);
		}
		int jsSize=key.hashCode()%arr.length;//对这个取模
		
		if(arr[jsSize]!=null){
			//不等于空就取出列表，将对象加入进去即可
			LinkedList<SxtEntry> linkList= (LinkedList<SxtEntry>) arr[jsSize];
			linkList.add(x);
			arr[jsSize]=linkList;
		}else{
			//等于空，则创建链表
			LinkedList<SxtEntry> list=new LinkedList<SxtEntry>();
			list.add(x);
			arr[jsSize]=list;
		}
		size++;
	}
	
	/***
	 * 
	
	* @Title: removeEntry
	
	* @Description: TODO(这里用一句话描述这个方法的作用)
	
	* @param @param key
	* @param @return    设定文件
	
	* @return SxtEntry    返回类型
	
	* @throws
	 */
	public static SxtEntry removeEntry(String key){
		int jsSize=key.hashCode()%arr.length;
		if(arr[jsSize]==null){
			//如果没有找到，则返回null,剔除失败
			return null;
		}else{
			LinkedList<SxtEntry> linkList= (LinkedList<SxtEntry>) arr[jsSize];
			for(SxtEntry sxt:linkList){
				if(sxt.key.equals(key)){
					//如果遇到，就干掉它
					linkList.remove(sxt);
				}
			}
			return null;
		}
	}
	
	public static SxtEntry getEntry(String key){
		int jsSize=key.hashCode()%arr.length;
		if(arr[jsSize]==null){
			//如果没有找到，则返回null,剔除失败
			return null;
		}else{
			LinkedList<SxtEntry> linkList= (LinkedList<SxtEntry>) arr[jsSize];
			for(SxtEntry sxt:linkList){
				if(sxt.key.equals(key)){
					//如果遇到，就返回这个对象
					return sxt;
				}
			}
			return null;
		}
	}
	
	
	
	public static void main(String[] args){
		
		//第一步放入对象，现在放入了20个对象
		for (int i=0;i<10;i++){
			addEntry("x"+i,"vvvv"+i);
		}
		for (int i=0;i<10;i++){
			//这时候就去扩容了
			addEntry("x==>"+i,"vvvv==>"+i);
			
			//addEntry("x==>"+i,"vvvv-->"+i);
		}
		
		//Object[] arr=new Object[instiallSize];
		System.out.println("map数组的大小为"+arr.length);
		//遍历map，取出里面所有的对象
		for(Object ls:arr){
			if(ls!=null){
				LinkedList<SxtEntry> list=(LinkedList<SxtEntry>)ls;
				for(SxtEntry sxt:list){
					if(sxt!=null){
						System.out.println(sxt.toString());
					}
				}
			}
		}
		
	
		//第二步传入key值得到对象
		SxtEntry entry=getEntry("x==>0");
		String s1=entry==null?null:entry.value;
		System.out.println("得到的value="+s1);
		
		
		//第三部，剔除key
		
		removeEntry("x==>0");
		SxtEntry entry2=getEntry("x==>0");
		String s2=(null==entry2?"":entry2.value);
		System.out.println("的到的value2="+s2);
		
		
		
		
	}
}

class SxtEntry{
	String key;
	String value;
	public SxtEntry(String key,String value){
		this.key=key;
		this.value=value;
	}
	@Override
	public String toString() {
		return "SxtEntry [key=" + key + ", value=" + value + "]";
	}
	public String getKey() {
		return key;
	}
	public void setKey(String key) {
		this.key = key;
	}
	public String getValue() {
		return value;
	}
	public void setValue(String value) {
		this.value = value;
	}
	
	
}

励志语：越长大越明白一句真理：机会是留给有准备的人的

V:18612372242 欢迎学习交流