ArrayList类的实现，利用数组存储元素

避免与类库中的ArrayList混淆，我将我实现的类命名为MyArrayList

基本思想：在MyArrayList内部用一个数组来存储插入元素，元素满则扩充数组容量。

实现细节如下：

1、保存基础数组，数组的容量，以及存储在MyArrayList中的当前项；

2、提供一种可以改变数组容量的机制，每当要插入元素且检查到当前存储元素的数组满时，便创建一个两倍容量的新数组，将老数组的元素复制到新数组，并将插入元素也插入新数组，回收老数组（垃圾回收机制）。

3、提供get和set的实现；

4、提供如size()/isEmpty()/clear()/remove/add()等方法；

5、提供一个实现Iterator的类，这个类存储迭代序列中的下一项的下标，提供next()/hasNext()/remove()等方法的实现。

实现代码如下：

import java.util.Iterator;
import java.util.NoSuchElementException;

/**
 * @description  ArrayList的实现 
 * @author Zhangx
 * @date 2015年12月1日 下午12:34:39
 * @version 1.0 
 */
public class MyArrayList<AnyType> implements Iterable<AnyType>{
	
	private static final int DEFAULT_CAPACITY = 10;   //默认初始大小
	
	private int theSize;              //当前元素个数
	private AnyType[] theItems;       //MyArrayList内部用来存储元素的数组
	
	public MyArrayList(){             //调用clear(),初始化List
		clear();
	}
	
	/**
	 * 将元素个数设置为0,并初始化一个大小为10的数组存储元素
	 */
	public void clear(){
		theSize = 0;
		ensureCapacity(DEFAULT_CAPACITY);
	}
	
	/**
	 * 获得list元素个数
	 * @return int
	 */
	public int size(){
		return theSize;
	}
	
	/**
	 * list是否为空
	 * @return boolean(true|false)
	 */
	public boolean isEmpty(){
		return size()==0;
	}
	
	/**
	 * 将list元素放入一个大小为元素个数的新数组
	 */
	public void trimToSize(){
		ensureCapacity(size());
	}
	
	/**
	 * 获得指定位置元素,如果索引超出数组范围则抛出异常
	 * @param idx
	 * @return AnyType
	 */
	public AnyType get(int idx){
		if(idx<0||idx>=size())
			throw new ArrayIndexOutOfBoundsException();
		
		return theItems[idx];
	}
	
	/**
	 * 在指定位置设置元素，如果索引超出数组范围则抛出异常
	 * @param idx
	 * @param newVal
	 * @return AnyType
	 */
	public AnyType set(int idx, AnyType newVal){
		if(idx<0||idx>=size()){
			throw new ArrayIndexOutOfBoundsException();
			
		AnyType old = theItems[idx];
		theItems[idx] = newVal;
		
		return old;
		}
	}
	
	/**
	 * 根据传入的大小，获得一个新数组，并将元素存储新数组
	 * @param newCapacity
	 */
	public void ensureCapacity(int newCapacity){
		if(newCapacity<theSize){
			return;
		}
		
		AnyType[] old = theItems;
		theItems = (AnyType[]) new Object[newCapacity];
		for(int i=0;i<size();i++){
			theItems[i] = old[i];
		}
	}
	
	/**
	 * 添加元素
	 * @param x
	 * @return boolean
	 */
	public boolean add(AnyType x){
		add(size(),x);
		return true;
	}
	
	/**
	 * 在指定位置增加元素，如果当前数组已满，则创建一个两倍大小的新数组，然后复制元素，插入元素
	 * @param idx
	 * @param x
	 */
	public void add(int idx, AnyType x){
		if(theItems.length==size()){
			ensureCapacity(size()*2);
		}
		
		for(int i=theSize;i>idx;i--){
			theItems[i] = theItems[i-1];
		}
		
		theItems[idx] = x;
		
		theSize++;
	}
	
	/**
	 * 删除指定位置元素，并将删除元素以后的元素前移一个位置
	 * @param idx
	 * @return
	 */
	public AnyType remove(int idx){
		AnyType removedItem = theItems[idx];
		for(int i=idx;i<size()-1;i++){
			theItems[i] = theItems[i+1];
		}
		
		theSize--;
		
		return removedItem;
	}
	
	@Override
	public Iterator<AnyType> iterator() {
		return new ArrayListIterator();
	}

	/**
	 * 迭代器
	 * @author Zhangxin
	 *
	 */
	private class ArrayListIterator implements Iterator<AnyType>{
		
		private int current = 0;    //记录一个位置的索引

		/**
		 * 判断索引当前位置的下一个位置是否还有元素
		 */
		@Override
		public boolean hasNext() {
			return current<size();
		}

		/**
		 * 返回索引当前位置的元素，并指向下一个元素
		 */
		@Override
		public AnyType next() {
			if(!hasNext()){
				throw new NoSuchElementException();
			}
			return theItems[current++];
		}

		/**
		 * 删除索引前一个位置的元素
		 */
		@Override
		public void remove() {
			MyArrayList.this.remove(--current);			
		}		
	}
	
}