java语言实现(动态)数组（附超详细的注释和时间复杂度的分析）

1. 数组的实现类——int型

public class Array {
	int size;  //数组实际装的元素
	int[] data;  //声明一个数组
	
	/**
	 * 有参的构造函数，可声明数组的容量
	 * @param capacity数组的容量
	 */
	public Array(int capacity) {
		data=new int[capacity];
		size=0;
	}
	
	/**
	 * 无参的构造函数，默认数组的容量为10
	 */
	public Array() {
		data=new int[10];
		size=0;
	}
	
	/**
	 * 获取数组的元素个数
	 * @return size数组的元素个数
	 */
	public int getSize() {
		return size;
	}
	
	/**
	 * 获取数组的容量
	 * @return capacity数组的容量
	 */
	public int getCapacity() {
		return data.length;
	}
	
	/**
	 * 判断数组是否为空
	 * @return 是否
	 */
	public boolean isEmpty() {
		return size==0;
	}
	
	/**
	 * 在数组索引index处，添加一个元素
	 * @param index  插入元素的位置
	 * @param e  元素
	 */
	public void add(int index,int e) {
		if (size==getCapacity())
			throw new IllegalArgumentException("数组容量已满");
		if (index<0||index>size)  //index不能为负，不能比数组的实际长度要大，当index=size时，正好添加在末尾
			throw new IllegalArgumentException("index错误");
		for (int i = data.length-1; i >=index; i--) {
			data[i+1]=data[i];
		}
		data[size]=e;
		size++;
	}

	/**
	 * 在所有元素的末尾添加一个元素
	 * @param e
	 */
	public void addLast(int e) {
//		if (size==getCapacity()) 
//			throw new IllegalArgumentException("数组容量已满");
//		data[size]=e;
//		size++;   //data[size++]=e;
		add(size, e);
	}
	
	/**
	 * 在数组头添加一个元素
	 * @param e
	 */
	public void addFirst(int e) {
		add(0, e);
	}
	
	/**
	 * 获取index处的元素
	 * @param index
	 * @return
	 */
	public int get(int index) {
		if (index<0||index>size)  //index不能为负，不能比数组的实际长度要大，当index=size时，正好添加在末尾
			throw new IllegalArgumentException("index错误");
		return data[index];
	}
	
	/**
	 * 修改index处的元素
	 * @param index
	 * @return
	 */
	public void set(int index,int e) {
		if (index<0||index>size)  //index不能为负，不能比数组的实际长度要大，当index=size时，正好添加在末尾
			throw new IllegalArgumentException("index错误");
		data[index]=e;
	}
	
	/**
	 * 查找数组是否含有e
	 * @param e
	 * @return
	 */
	public boolean contains(int e) {
		for (int i = 0; i < size; i++) {
			if (data[i]==e) {
				return true;
			}
		}
		return false;
	}
	
	/**
	 * 查找数组中元素e所对应的位置
	 * @param e
	 * @return 找到了返回所在的索引，找不到返回-1
	 */
	public int find(int e) {
		for (int i = 0; i < size; i++) {
			if (data[i]==e) {
				return i;
			}
		}
		return -1;
	}
	
	/**
	 * 删除index处的元素
	 * @param index
	 * @return 被删除的元素
	 */
	public int remove(int index) {
		if (index<0||index>=size)  //index不能为负，要小于数组的实际长度
			throw new IllegalArgumentException("index错误");
		int res=data[index];
		for (int i = index+1; i < data.length; i++) {
			data[i-1]=data[i];
		}
		size--;
		return res;
	}
	
	/**
	 * 删除数组中元素e第一次出现的索引
	 * @param e
	 * @return 是否删除
	 */
	public boolean removeElement(int e) {
		int res = find(e);
		if (res!=-1) {
			remove(res);
			return true;
		}
		return false;
	}
}

2. 使用泛型

public class Array<E> {
	int size;  //数组实际装的元素
	E[] data;  //声明一个数组
	
	/**
	 * 有参的构造函数，可声明数组的容量
	 * @param capacity数组的容量
	 */
	public Array(int capacity) {
//		data=new E[capacity];  不能直接new一个泛型
		data=(E[])new Object[capacity];  //需要先new一个object类型的数组再转泛型
		size=0;
	}
	
	/**
	 * 无参的构造函数，默认数组的容量为10
	 */
	public Array() {
		data=(E[])new Object[10];
		size=0;
	}
	
	/**
	 * 获取数组的元素个数
	 * @return size数组的元素个数
	 */
	public int getSize() {
		return size;
	}
	
	/**
	 * 获取数组的容量
	 * @return capacity数组的容量
	 */
	public int getCapacity() {
		return data.length;
	}
	
	/**
	 * 判断数组是否为空
	 * @return 是否
	 */
	public boolean isEmpty() {
		return size==0;
	}
	
	/**
	 * 在数组索引index处，添加一个元素
	 * @param index  插入元素的位置
	 * @param e  元素
	 */
	public void add(int index,E e) {
		if (size==getCapacity())
//			throw new IllegalArgumentException("数组容量已满");
			resize(2*data.length);  //使扩容前后的数组在同一数量级，提升性能
		if (index<0||index>size)  //index不能为负，不能比数组的实际长度要大，当index=size时，正好添加在末尾
			throw new IllegalArgumentException("index错误");
		for (int i = data.length-1; i >=index; i--) {
			data[i+1]=data[i];
		}
		data[size]=e;
		size++;
	}

	/**
	 * 在所有元素的末尾添加一个元素
	 * @param e
	 */
	public void addLast(E e) {
//		if (size==getCapacity()) 
//			throw new IllegalArgumentException("数组容量已满");
//		data[size]=e;
//		size++;   //data[size++]=e;
		add(size, e);
	}
	
	/**
	 * 在数组头添加一个元素
	 * @param e
	 */
	public void addFirst(E e) {
		add(0, e);
	}
	
	/**
	 * 获取index处的元素
	 * @param index
	 * @return
	 */
	public E get(int index) {
		if (index<0||index>size)  //index不能为负，不能比数组的实际长度要大，当index=size时，正好添加在末尾
			throw new IllegalArgumentException("index错误");
		return data[index];
	}
	
	/**
	 * 修改index处的元素
	 * @param index
	 * @return
	 */
	public void set(int index,E e) {
		if (index<0||index>size)  //index不能为负，不能比数组的实际长度要大，当index=size时，正好添加在末尾
			throw new IllegalArgumentException("index错误");
		data[index]=e;
	}
	
	/**
	 * 查找数组是否含有e
	 * @param e
	 * @return
	 */
	public boolean contains(E e) {
		for (int i = 0; i < size; i++) {
			if (data[i]==e) {
				return true;
			}
		}
		return false;
	}
	
	/**
	 * 查找数组中元素e所对应的位置
	 * @param e
	 * @return 找到了返回所在的索引，找不到返回-1
	 */
	public int find(E e) {
		for (int i = 0; i < size; i++) {
			if (data[i]==e) {
				return i;
			}
		}
		return -1;
	}
	
	/**
	 * 删除index处的元素
	 * @param index
	 * @return 被删除的元素
	 */
	public E remove(int index) {
		if (index<0||index>=size)  //index不能为负，要小于数组的实际长度
			throw new IllegalArgumentException("index错误");
		E res=data[index];
		for (int i = index+1; i < data.length; i++) {
			data[i-1]=data[i];
		}
		size--;
		data[size]=null;  //泛型中存放的是类对象，如果没有用不置空的话不会被GC回收。闲散对象！=内存溢出
//		if (size==data.length/2) {
//			resize(data.length/2);  //删除到一定长度后，减小数组的容量
//		}
		if (size==data.length/4&&data.length/2!=0) {  //采用的策略，当数组长度为1/4时，才减小数组容量，为了防止复杂度震荡，保持O(1)的复杂度
		resize(data.length/2);  //删除到一定长度后，减小数组的容量（data.length！=1）
	}
		return res;
	}
	
	/**
	 * 删除数组中元素e第一次出现的索引
	 * @param e
	 * @return 是否删除
	 */
	public boolean removeElement(E e) {
		int res = find(e);
		if (res!=-1) {
			remove(res);
			return true;
		}
		return false;
	}

	/**
	 * 扩容数组（声明为private不允许用户调用）
	 * @param newCapacity
	 */
	private void resize(int newCapacity) {
		E[] newdata=(E[])new Object[newCapacity];
		for (int i = 0; i < data.length; i++) {
			newdata[i]=data[i];
		}
		data=newdata;
	}
}

3. 时间复杂度
添加操作：
addLast(e); O(1)
addFirst(e); O(n)
add(index,e); O(n/2)=O(n)
resize(newCapacity); O(n)
删除操作：
removeLast(e); O(1)
removeFirst(e); O(n)
remove(index,e); O(n/2)=O(n)
resize(newCapacity); O(n)
修改操作：
set(e); O(1)
查找操作：
get(e); O(1)
contains(e); O(n)
find(e); O(n)