java【ArrayList底层实现】

/***
* list集合的底层使用数组实现的
* 数组的特点是 读取快，因为内存是连续的 插入删除慢
*
* 链表的特点相反 ： 读取慢，因为需要内存不是连续的，需要找到头节点，顺序遍历。但是插入删除会很快
*/

package com.bjsxt.collection;

import java.util.ArrayList;
import java.util.List;

import sun.misc.SharedSecrets;

public class MyList {
	
	private Object[] installArr={};
	
	private Object[] elementData=null;
	
	private int size=0;//记录里面到底存储了几个元素
	
	private int installSize=10;
	public MyList(){
		//比较方便，这里我这么写
		this.elementData=new Object[installSize];
	}
	
	public MyList(int sizeParam) throws Exception{
		if(this.size<=0){
			throw new Exception("越界");
		}
		this.elementData=new Object[sizeParam];
	}
	
	public void add(Object obj){
		grow();//若有必要扩容，没必要的话自己玩
		elementData[size]=obj;
		size++;
	}
	
	//移除某个元素 此处不考虑obj为null的情况
	public void remove(Object obj){
		//需要遍历数组，找打他 干掉他
		for(int i=0;i<elementData.length; i++){
			Object ob=elementData[i];
			if(ob.equals(obj)){
				int numMoved = size - i - 1;
		        if (numMoved > 0){
		        	//这个函数的意思
		        	//第一个elementData是原来的数组
		        	//第二个elementData是新的数组，这里只不过是特殊，为了不再新建一个数组就用了他自己
		        	//第二个参数 的意思是 要复制元素的的起始下标
		        	//第四个传参数的意思是 覆盖到新数组的 起始下标
		        	//第五个参数是从原数组复制的长度是多少
		            System.arraycopy(elementData, i+1, elementData, i,
		                             numMoved);
		            //此时size应该减少1个了
		            size--;
		            //到这完事了，没有，我们要把原来最后一个元素置为空才行啊 你说呢
		            //因为中间少了一个元素，最后一个元素的值没有被覆盖还在那儿呢
		            System.out.println("size的值为"+size);
		            elementData[size]=null;
		            
		        }    
		        break;
			}
		}
	}
	
	//获得集合里面的对象
	Object getValue(int index ) throws Exception{
		indexIsvalid(index);
		return elementData[index];
	}	
	
	
	//检查数组越界	
	void indexIsvalid(int index ) throws Exception{
		if(index<0||index>size){
			throw new Exception("越界啦");
		}
	}
	
	//扩容
	public void grow(){
		if(size==elementData.length){
			Object[] elementDataNew=new Object[size*2+10];//规则自己定义
			System.arraycopy(elementData, 0, elementDataNew, 0, size);
			elementData=elementDataNew;
			System.out.println("扩容成功，现在的数组大小为"+elementData.length);
		}
	}
	
	//遍历List
	public void whileMyList(){
		//相当于遍历数组
		for(Object obj:elementData){
			if(obj!=null){
				System.out.println(obj);
			}else{
				System.out.println("null");
			}
			
		}
	}

	public static void main(String[] args) throws Exception {
		
		MyList list=new MyList();
		
		for(int i=0;i<15;i++){
			list.add(i);
		}
		
		list.whileMyList();
		System.out.println("剔除一个元素");
		list.remove(10);
		System.out.println("剔除一个元素后，数组长度"+list.elementData.length);
		list.whileMyList();
		
		Object obj=list.getValue(3);
		System.out.println("getValue方法得到的对象是"+obj);
				
	}

}

扩容成功，现在的数组大小为30
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
null
null
null
null
null
null
null
null
null
null
null
null
null
null
null
剔除一个元素
size的值为14
剔除一个元素后，数组长度30
0
1
2
3
4
5
6
7
8
9
11
12
13
14
null
null
null
null
null
null
null
null
null
null
null
null
null
null
null
null
getValue方法得到的对象是3

上面的程序使用数组实现了ArrayList，里面用到了一个很重要的方法， System.arraycopy这个的作用就是将一个数组从某个下标开始的后续n个元素，插入到另一个数组从某个下标开始后的n个元素

比如：第一个数组arrOld是 {1，2，3，4，5} //长度为5

第二个数组arrValue是int[] arrNew=new int[8];//长度为8

下面我要实现将old数组的 3,4,5复制到新数组第四到第六个位置，那么我该怎么做呢。

int[] arrOld=new int[] {1,2,3,4,5};
		
		int[] arrNew=new int[8];
		System.arraycopy(arrOld, 2, arrNew, 3, 3);
		for(int i:arrNew){
			System.out.print(i+"==》");
		}

输出的结果如下；

0==》0==》0==》3==》4==》5==》0==》0==》

//这个函数的意思
//第一个elementData是原来的数组
//第二个elementData是新的数组，这里只不过是特殊，为了不再新建一个数组就用了他自己
//第二个参数 的意思是 要复制元素的的起始下标
//第四个传参数的意思是 覆盖到新数组的 起始下标
//第五个参数是从原数组复制的长度是多少
System.arraycopy(elementData, i+1, elementData, i,
numMoved);