我的ArrayList实现

package ArrayList;
/**
 * <p>MyArrayList是个动态数组,初始容量为10的空列表</p>
 * <p>在添加大量元素前，应用程序可以使用 ensureCapacity 操作来增加 ArrayList 实例的容量.这可
 * 以减少递增式再分配的数量</p>
 * @author baby69yy2000
 */
public class MyArrayList<T> {
	private T[] listArr;
	private int listSize;

	/**
	 * 构造一个初始容量为10的空列表
	 */
	public MyArrayList() {
		listArr = (T[]) new Object[10];
		listSize = 0;
	}

	/**
	 * <p>方法ensureCapacity是MyArrayList类实现的一个重要操作, 它提供了允许ArrayList对象
	 * 进行动态增长的存储空间管理工具</p>
	 * <p>在MyArrayList对象的大小等于其容量时, 分配一个更大的数组, 并将已有值复制到新数组中</p>
	 * @param minCapacity 所需的最小容量
	 */
	public void ensureCapacity(int minCapacity) {
		int currentCapacity = listArr.length;
		if(minCapacity > currentCapacity) {
			T[] oldlistArr = listArr;
			listArr = (T[]) new Object[minCapacity];
			for (int i = 0; i < listSize; i++) {
				listArr[i] = oldlistArr[i];
			}
			oldlistArr = null;
		}
	}

	/**
	 * 将此 MyArrayList 实例的容量调整为列表的当前大小
	 */
	public void trimToSize() {
		int oldCapacity = listArr.length;
		if(listSize < oldCapacity) {
			T[] oldlistArr = listArr;
			listArr = (T[]) new Object[listSize];
			for (int i = 0; i < listSize; i++) {
				listArr[i] = oldlistArr[i];
			}
			oldlistArr = null;
		}
	}

	/**
	 * MyArrayList的连接
	 * 把listB放到listA的末尾
	 */
	public static <T> void joinList(MyArrayList<T> listA, MyArrayList<T> listB) {
		int sizeA = listA.size(), sizeB = listB.size();
		listA.ensureCapacity(sizeA + sizeB);
		for(int i = 0; i < sizeB; i++)
			listA.add(listB.get(i));
	}

	/**
	 * 求listArr的长度
	 * @return listArr长度
	 */
	public int listArrLength() {
		return listArr.length;
	}

	/**
	 * 数组下标越界检查函数
	 */
	private void rangeCheck(int index, String s, int upperBound) {
		if(index < 0 || index >= upperBound + 1) {
			throw new IndexOutOfBoundsException("\n" + s + ": index" + index +
					"out of bounds. Should be in the range 0 to " + upperBound);
		}
	}

	/**
	 * 将指定的元素插入此列表中的指定位置.向右移动当前位于该位置的元素（如果有）以及所有后续元素
	 * (将其索引加 1)
	 * @param index 指定元素所插入位置的索引
	 * @param item  要插入的元素
	 * @throws IndexOutOfBoundsException
	 */
	public void add(int index, T item) {
		rangeCheck(index, "MyArrayList add()", listSize);

		if(listSize == listArr.length) 
			ensureCapacity(2*listArr.length);

		for(int j = listSize - 1; j >= index; j--)
			listArr[j + 1] = listArr[j];

		listArr[index] = item;
		listSize++;
	}

	/**
	 * 将指定的元素追加到此列表的尾部
	 * @param item 要追加到此列表中的元素
	 */
	public boolean add(T item) {
		add(listSize, item);	
		return true;
	}

	/**
	 * 返回列表中首次出现指定元素的索引
	 * @param item 要搜索的元素
	 * @return 返回列表中手册出现指定元素的索引，如果列表不包含该元素，则返回 -1
	 */
	public int indexOf(T item) {
		int i = 0;
		int last = listSize - 1;
		while(i <= last && listArr[i] != item) i++;
		if(i > last) return -1;
		else return i;
	}

	/**
	 * 移除此列表中指定位置上的元素. 向左移动所有后续元素（将其索引减 1）
	 * @param index 要移除的元素的索引
	 * @return 从列表中移除的元素
	 * @throws IndexOutOfBoundsException
	 */
	public T remove(int index) {
		rangeCheck(index, "MyArrayList remove()", listSize - 1);

		T returnElement = listArr[index];
		for (int j = index; j < listSize - 1; j++)
			listArr[j] = listArr[j + 1];
		listArr[listSize - 1] = null;
		listSize--;
		return returnElement;
	}

	/**
	 * 移除列表中出现的首个指定元素
	 * @param item 要从此列表中移除的元素(如果存在)
	 * @return 如果此列表包含指定的元素，则返回 true
	 */
	public boolean remove(T item) {
		int i = 0;
		boolean returnValue = true;
		if((i = indexOf(item)) != -1)
			remove(i);
		else
			returnValue = false;
		return returnValue;
	}

	/**
	 * 如果此列表中包含指定的元素，则返回 true
	 * @param item 要测试列表中是否存在的元素
	 * @return 如果列表包含指定的元素，则返回 true
	 */
	public boolean contains(T item) {
		return indexOf(item) >=0;
	}

	/**
	 * 返回此列表中指定位置上的元素
	 * @param index 所返回元素的索引
	 * @return 此列表中指定位置上的元素
	 */
	public T get(int index) {
		rangeCheck(index, "MyArrayList get()", listSize - 1);
		return listArr[index];
	}

	/**
	 * 用指定的元素替代此列表中指定位置上的元素
	 * @param index 要替代的元素的索引
	 * @param item 指定的元素
	 * @return 以前位于该指定位置上的元素
	 */
	public T set(int index, T item) {
		T oldValue = listArr[index];
		listArr[index] = item;
		return oldValue;
	}

	/**
	 * 返回一个按照正确的顺序包含此列表中所有元素的数组
	 * @return 一个按照正确的顺序包含此列表中所有元素的数组
	 */
	public Object[] toArray() {
		Object[] result = new Object[listSize];
		//System.arraycopy(listArr, 0, result, 0, listSize);
		for (int i = 0; i < listSize; i++) {
			result[i] = listArr[i];
		}
		return result;
	}

	/**
	 * 反转列表
	 */
	public void reverse() {
		T temp;
		int size = this.size();
		for(int i = 0, j = listSize - 1, mid = size>>1; i < mid; i++, j--) {
			temp = listArr[i];
			listArr[i] = listArr[j];
			listArr[j] = temp;
		}
	}

	/**
	 * 返回此列表中的元素数
	 * @return 此列表中的元素数
	 */
	public int size() {
		return listSize;
	}

	/**
	 * 测试此列表中是否有元素
	 * @return 如果此列表中没有元素，则返回 true；否则返回 false
	 */
	public boolean isEmpty() {
		return listSize == 0;
	}

	/**
	 * 移除此列表中的所有元素
	 */
	public void clear() {
		for (int i = 0; i < listSize; i++)
			listArr[i] = null;
		listSize = 0;
	}

	public static void main(String[] args) {
		MyArrayList<String> listA = new MyArrayList<String>();
		MyArrayList<String> listB = new MyArrayList<String>();
		//mal.ensureCapacity(100);
		listA.add("A");
		listA.add("B");
		listA.add("C");
		listA.add("D");
		listA.add("E");
		listA.reverse();
		//listB.add("F");
		//listB.add("G");

		//listA.joinList(listA, listB);
		//listA.reverse();
		for (int i = 0; i < listA.size(); i++) {
			System.out.println(listA.get(i));
		}
		/*Object[] s = mal.toArray();
		for (int i = 0; i < s.length; i++) {
			System.out.println(s[i].toString());
		}*/
		//mal.trimToSize();
		/*System.out.println(mal.listArrLength()); // 4
		System.out.println(mal.size()); // 4
		mal.clear();
		System.out.println(mal.listArrLength()); // 4
		System.out.println(mal.size());*/ // 0

		/*mal.add(new Point(2, 3));
		mal.add(new Point(8, 9));
		Object[] objs = mal.toArray();
		for (int i = 0; i < objs.length; i++) {
			System.out.println(objs[i]);
		}*/
		/*System.out.println(mal.indexOf("C"));	// 2
		System.out.println(mal.indexOf("E"));	// -1
		System.out.println(mal.contains("A"));	// true
		System.out.println(mal.remove("B"));
		mal.add(2, "BB");
		for (int i = 0; i < mal.size(); i++) {
			System.out.println(mal.get(i));
		}
		System.out.println(mal.isEmpty());
		System.out.println(mal.remove("B"));
		System.out.println(mal.size());*/
	}

}

class Point {
	int x, y;
	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}

	public String toString() {
		return "x = " + x + " y = " + y;
	}
}