实现 MyArrayList 类

模拟ArrayList类实现

public class MyArrayList{
	//实际元素的数目
 	private int size=0;
 
	 //底层数组
	 private Object[] elementData;
 
	/*
  	* 无参构造器
  	* 初始化一个长度为10的对象数组 
  	*/
 	public MyArrayList() {
 		 elementData=new Object[10];
 	}
 	
 	/*
  	* 有参构造器
  	* 初始化一个长度为initCapacity的对象数组 
 	 */
 	public MyArrayList(int initCapacity) {
  		if(initCapacity>10) {
  			 elementData=new Object[initCapacity];
  		}else {
   			elementData=new Object[10]; 
 		 }
 	} 
 	
 	 /*
	  * 将元素追加到数组尾部 
	  */
	 public void add(Object obj) {
	   ensureCapacity(size+1);
      	   elementData[size++]=obj;
 	}
 
	 /*
	  * 将元素插入到数组下标为index处 
	  */
	 public void add(int index, Object obj) {
		  if (index>size||index<0) {
		   IndexOutOfBoundsException ex=new IndexOutOfBoundsException("索引超出边界!");
		   throw ex;
		  }
		  ensureCapacity(size + 1);
		  for(int i=index;i<size;i++) {
		   elementData[i+1]=elementData[i];
		  }
		  elementData[index]=obj;
	         size++;
 	}
 	
	  /*
	  * 清除对象数组中的所有元素 
	  */
	 public void clear() {
	  for (int i=0; i<size;i++) {
	   elementData[i] = null;
	  }
	        size = 0;
	 }
	 
	 /*
	  * 查询对象数组中是否存在对象obj 
  	  */
	 public boolean contains(Object obj){
		  for(int i=0;i<size;i++) {
		   	if(elementData[i].equals(obj)) {
		   		 return true;
		   	}
		  }
		  return false;
	 }
	 
	 /*
 	 * 自动扩容 
  	*/
	 public void ensureCapacity(int minCapacity) {
		  if(minCapacity>elementData.length) {
		   	int oldCapacity=elementData.length;
		   	int newCapacity=oldCapacity+(oldCapacity>>1); //1.5倍
		   	Object[] temp=elementData;
		   	elementData=new Object[newCapacity];
		   	for(int i=0;i<size;i++) {
	    			elementData[i]=temp[i];
	  	  	}
	     	 }
 	}
 	
	/*
	  *  获取对象数组中下标index处的元素 
	  */
	 public Object get(int index) {
	 	 if(index>=size) {
	   		IndexOutOfBoundsException ex=new IndexOutOfBoundsException("索引超出边界!");
	   		throw ex;
	 	 }
	 	 return elementData[index];
	 }
	 
	 /*
	  *  查询对象数组中 对象obj 第一次出现的位置 [>0 | -1] 
	  */
	 public int indexOf(Object obj) {
	  	int index=-1;
	  	for (int i=0; i<size; i++) {
	     		 if (obj.equals(elementData[i])) {
	       			index=i;
	      			 break;
	     		 }
	 	 }
	  return index;
	 }
	 
	 /*
	  *  判断对象数组中是否存在元素 [存在元素 返回false] 
	  */
	 public boolean isEmpty() {
	  	if(size==0) {
	  		 return true;
	  	}
	  	return false;
	 }
	 
	 /*
	  *  查询对象数组中 对象obj 最后一次出现的位置 [>0 | -1] 
	  */
	 public int lastIndexOf(Object obj) {
	  	int index=-1;
	  	for (int i=size-1; i>=0; i--) {
	         	if (obj.equals(elementData[i])) {
	          		index=i;
	       			break;
	       		  }
	     	}
	  	return index;
	 }
	 
	 /*
	  *  移除数组中 index处的元素 
	  */
	 public void remove(int index) {
		  if(index>=size) {
		   IndexOutOfBoundsException ex=new IndexOutOfBoundsException("索引超出边界!");
		   throw ex;
		  }
		  for(int i=index;i<size-1;i++) {
		   elementData[i]=elementData[i+1];
		  }
	  	elementData[--size] = null; 
	 }
	 
	 /*
	  *  获取数组中实际元素数目 
	  */
	 public int size() {
	  	return size;
	 }
	 
	 /*
	  * 获取容量
	  */
	 public int capacity() {
	  	return elementData.length;
	 }
	 /*
	  *  将List的内容 填充到一个对象数组 
	  */
	 public Object[] toArray() {
  		Object[] obj=new Object[size];
	        for(int i=0;i<size;i++) {
  			 obj[i]=elementData[i];
  		}
 		 return obj;
	 }
}

优缺点分析
ArrayList由于底层是基于数组的实现,数组内存是连续的内存空间,所以ArrayList延续了数组在数据处理方面的优缺点:
优点:连续的存储地址->查询效率高(遍历或随机访问)

缺点:数组大小的固定性->一旦对数组进行移除或插入操作,会带来很大的能耗(效率低,不建议)