Java集合类（ ArrayList LinkedList HashMap底层实现）

最近在复习数据结构，于是把java集合类重新复习一遍~~

ArrayList基本方法的底层实现：

public class MyArrayList {
   
   //实质是一个数组 
   private Object[]  ElementData;
   //集合大小[注：集合大小用size表示，数组大小才有length]
   private int size;
   
   //构造函数  没有自定义长度的话 会先自动给一个容量
   public  MyArrayList() {
	   this(10);
   }

   //数组的初始化  自定义大小
   public MyArrayList(int capacity) {
	  if(capacity<0) {
				try {
					throw new Exception();
				} catch (Exception e) {
					e.printStackTrace();
				}		
	      }
	  ElementData=new Object[capacity];//数组初始化 指定数组大小
	   
   }

   //元素的增加
   public void add(Object obj) {
	   //如果集合满了 就对集合进行扩容
	   if(size==ElementData.length) {
		   Object[] newArray=new Object[size*2+1];
		   System.arraycopy(ElementData, 0, newArray,0,ElementData.length);
		   ElementData=newArray; //现在才发现不同长度的数组也可以这样赋值
	   }
	   ElementData[size]=obj;
	   size++; //别忘了向集合中添加一个元素之后，集合的size就会+1
   }
   
   public void remove(int i) {
	   ElementData[i]=null;
	   size--; //删除元素同理
   }
   
   
   public Object get(int index) {
	   return ElementData[index];
	   
   }
   public boolean isEmpty() {
	 /*
	   if(size==0) {
		   return true;
	   }
	   else {
		   return false;
	   }
	   */
	   return size==0;
   }
   }

MyLinkedList基本方法底层实现：
Node类

//每一个节点可看成链式线性表中每一个完整的小部分
public class Node {

   //一个完整节点的三个属性   一个节点包含3个节点的信息（上一个节点   存储的对象表示当前节点本身  后一个节点）
   Node previous;//上一个节点
   Node next;//后一个节点、
   Object obj;
   
   public Node() {
		
	}
   
public Node(Node previous, Node next, Object obj) {
	super();
	this.previous = previous;
	this.next = next;
	this.obj = obj;
}

public Node(Object obj) {
	this.obj = obj;
}

public Node getPrevious() {
	return previous;
}

public void setPrevious(Node previous) {
	this.previous = previous;
}

public Node getNext() {
	return next;
}

public void setNext(Node next) {
	this.next = next;
}

public Object getObj() {
	return obj;
}

public void setObj(Object obj) {
	this.obj = obj;
}
   
   
   
}

基本方法实现

public class MyLinkedList {
    
	//链式链表的三个属性
	Node FirstNode; //首节点
	Node LastNode;//尾结点
	int size;//节点个数 其实就是MyLinkedList集合的容量
	
	
	//获取集合的容量
	public int size() {
		return size;
	}
	
	
	//在链表的末尾添加元素 
	public void add(Object obj) {
		
		Node node=new Node(obj);
		//如果链表为空
		if(size==0) {
			FirstNode=node;
			LastNode=node;
		}else {              //链表不为空
			LastNode.setNext(node);
			node.setPrevious(LastNode);
			LastNode=node;
		}
		size++;
	}
	
    //根据index取出某一节点中存放的对象
	public Object get(int index) {
		
		//index异常处理
				if(index<0||index>size-1) {
					try {
						throw new Exception();
					}catch (Exception e) {
						e.printStackTrace();
					}
				}
				
		Node temp=FirstNode;
		for(int i=0;i<index;i++) {
			temp=temp.getNext();
		}
		return temp.getObj();
	}
	 
	//移除某一个节点
	public void remove(int index) {
		
		//index异常处理
		if(index<0||index>size-1) {
			try {
				throw new Exception();
			}catch (Exception e) {
				e.printStackTrace();
			}
		}
		
		if(index==size-1) {   //如果是移除最后一个节点
			Node upNode=LastNode.previous;
			LastNode=upNode;
			LastNode.setNext(null);
		}
		
		if(index==0) {   //如果移除的是第一个节点
			Node secondNode=FirstNode.next;
			secondNode.setPrevious(null);
			FirstNode=secondNode;
			
		}
		
		Node temp=FirstNode;
		for(int i=0;i<index;i++) {
			temp=temp.next;
		}
		
		Node up=temp.previous;
		Node down=temp.next;
		
		up.setNext(down);
		down.setPrevious(up);
		
		
		size--;
	}

HashMap基本方法底层实现：
HashMap的实质是一个存放对象()含有两个属性key value）的数组:
ElementData类：

public class ElementData {

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


	
}

基本方法实现

//Map底层实现的实质是一个存放对象（含有两个属性 key 、value）的数组
public class MyMap {
	
   ElementData[] element=new ElementData[999];   
   int size;
   
   public int size() {
	   return size;
   }
   
   
   //往Map中添加键值对
   public void put(Object key,Object value) {  //Map中不会有重复的key  相同的key会被后来者覆盖
	   
	   ElementData e=new ElementData(key,value);
	   for(int i=0;i<size;i++) {
		   if(key.equals(element[i].key)) {
			   element[i].value=value;
			   return;
		   }
		  
	   }
	   element[size]=e;
	   size++;
   }
   
   //根据键 获取Map中对应的value值
   public Object getValue(Object key) {
	   for(ElementData e:element) {
		   if(key.equals(e.key)) {
			   return e.value;
		   }
	   }
	return null;
   }
   
   //根据键 移除Map中的某个键值对
   public void  remove(Object key) {
	   for(ElementData e:element) {
		   
		   for(int i=0;i<size;i++) {
			   if(key.equals(element[i].key)) {
				   for(int j=i;j<size-1;j++) {
					   element[i]=element[i+1];
					   
				   }
				   size--;
			   } 
	   }
	  
   }
	   
   }
    //判断Map中是否含有某个键
   public  boolean contains(Object key) {
	   for(ElementData e:element) {
		   if(key.equals(e.key)) {
			   return true;
		   }
	   }
	   return false;
   }
   }

//为了简化Map查询    底层用一个存放LinkedList的数组来实现
public class MyMap002 {
	
    LinkedList[] array=new LinkedList[9999];
    int size;
  
    public int size() {
    	return size;
    }
    
    public void put(Object key,Object value) {
    	
    	ElementData e=new ElementData(key,value);
    	int hash=key.hashCode();
    	hash= hash>0?hash:-hash;//A=(一个判断条件？(成立的结果):(条件不成立的结果))
    	int a=hash%array.length;
    	
    	if(array[a]==null) {
    		LinkedList<ElementData> list=new LinkedList<>(); 
    		array[a]=list;  //一个需要注意的bug: 当array[a]为空时 需要在该位置创建一个链表 创建完链表之后一定要记得将其存放到数组中 否则后期将访问不到
    		list.add(e);
    		
    	}else {
    		LinkedList<ElementData> list=array[a];
    		for(int i=0;i<list.size();i++) {
    			if(list.get(i).key.equals(key)) {
    				list.get(i).value=value;
    				return;
    			}
    			array[a].add(e);
    		}
    		
    	}
    	size++;  
    }
    
    
    public void remove(Object key) {
    	int hash=key.hashCode();
    	hash= hash>0?hash:-hash;
    	int a=hash%array.length;
    	
    	if(array[a]!=null) {
    	   LinkedList<ElementData> list=new LinkedList<>();
    	   list=array[a];
    	   for(int i=0;i<list.size();i++) {
    		   ElementData e=list.get(i);
    		   if(e.key==key) {
    			   list.remove(i);
    		   }
    	   }
    	   size--;
    	}else {
    		return;
    	}
    }
    
    public Object get(Object key) {
    	int hash=key.hashCode();
    	hash= hash>0?hash:-hash;
    	int a=hash%array.length;
    	if(array[a]!=null) {
    		LinkedList<ElementData> list=array[a];
    		for(int i=0;i<list.size();i++) {
    			ElementData e=(ElementData)list.get(i);
    			if(e.key.equals(key)) {
    				return e.value;
    			}	
    		}
    			
    		}
    	return null;
    	}
    	}