一个简易自定义ArrayList的实现

一个自定义可变长度数组的java实现

package com.ccy.List;

import java.util.Iterator;
/**
 * ArrayList的自定义实现
 * 
 * @author ccy
 *	
 * @param <E> 
 */
public class MyArrayList<E> implements MyList<E>{
	
	private int size;
	private static final int DEFALUT_LENGTH = 10;
	private Object[] array;
	
	/**
	 * 创建一个自定义长度的ArrayList
	 * 
	 * @param length 想要的数组初始化长度，最少为10
	 */
	public MyArrayList(int length){
		if(length<=10)
			this.array = new Object[DEFALUT_LENGTH];
		else {
			this.array = new Object[length];
		}							
		size = 0;
	}
	
	/**
	 * 创建一个默认长度为10的数组
	 */
	public MyArrayList(){
		this.array = new Object[DEFALUT_LENGTH];
		size = 0;
	}
	/**
	 * 获取数组的长度
	 * @return the size of the ArrayList
	 */
	@Override
	public Integer size(){
		return this.size;
	}
	
	/**
	 * 添加元素到尾部
	 * 
	 * @param element 需要添加的元素
	 */
	@Override
	public void add(E element){
		expend();
		array[size++] = element;
	}
	
	/**
	 * 
	 * @param element
	 * @param index
	 */
	public void add(E element,int index) {
		this.indexCheck(index);
		this.expend();
		System.arraycopy(array, index, array, index+1, size-index);
		array[index] = element;
		size++;
		
	}
	
	
	/**
	 * 通过下标获取元素
	 * 
	 * @param index 想要获取元素的下标
	 * @return 该下标对应的元素
	 * @throws ArrayIndexOutOfBoundsException 下标越界时抛出异常
	 */
	public E get(int index){
		this.indexCheck(index);
		return (E)array[index];
	}
	
	/**
	 * 确定是否需要对数组进行扩容，若需要，新数组长度等于老数组长度乘3/2
	 */
	private void expend(){
		if(size == array.length) {
			Object[] temp = array;
			array = new Object[size + (size>>1)];
			System.arraycopy(temp, 0, array, 0, size);
		}
	}
	/**
	 * 查看是否包含元素
	 * 
	 * @param element 查找的元素
	 * @return 包含则true，不包含则false
	 */
	@Override
	public boolean isContain(E element) {
		return this.indexOf(element)>=0;
	}
	
	/**
	 * 检测下标是否越界
	 * 
	 * @param index 需检测下标
	 * @throws ArrayIndexOutOfBoundsException
	 */
	private void indexCheck(int index) {
		if(index<0 || index>=size)
			throw new ArrayIndexOutOfBoundsException("下标越界");
	}
	
	/**
	 * 查找元素的下标
	 * 
	 * @param object 查找的元素
	 * @return 存在则返回其下标，不存在则返回-1
	 */
	@Override
	public int indexOf(Object object) {
		for(int i=0;i<size;i++) {
			if(array[i].equals(object))
				return i;
		}
		return -1;
	}
	
	/**
	 * 
	 * @param elemet 将被删除的元素
	 */
	public void remove(E elemet) {
		int index = this.indexOf(elemet);
		if(index != -1) {
			System.arraycopy(array, index+1, array, index, size-index-1);
			size--;
		}
	}
	
	public void remove(int index) {
		indexCheck(index);
		System.arraycopy(array, index+1, array, index, size-index-1);
		size--;
	}
	/**
	 * 将某个下标对应的元素设定为某个值
	 * 
	 * @param index 
	 * @param element
	 */
	public void set(E element,int index) {
		indexCheck(index);
		array[index] = element;
	}
	
	/**
	 * 检测有效数组是否为空
	 */
	@Override
	public boolean isEmpty() {
		return size == 0;
	}
	

	@Override
	public Iterator<E> iterator() {
		return new MyListIterator<E>();
	}
	
	private class MyListIterator<E> implements Iterator<E>{

		private int pos = 0;
		@Override
		public boolean hasNext() {
			return pos<size;
		}

		@Override
		public E next() {
			if(pos<size)
				return (E)array[pos++];
			else
				throw new ArrayIndexOutOfBoundsException();
		}
		
	}

	@Override
	public String toString() {
		StringBuilder stringBuilder = new StringBuilder();
		stringBuilder.append("[");
		for(int i=0;i<size;i++)
			stringBuilder.append(array[i]+",");
		stringBuilder.setCharAt(stringBuilder.length()-1, ']');
		return stringBuilder.toString();
	}
}