通过手写实现动态数组，了解数组

动态数组

动态数组简介

数组定义后，其容量大小就已经固定。而动态数组，也就是数组的容量大小可以变化，也可以删除某一数组下标值，也可以在某一个下标处添加一个数据。

具体实现方式

为了实现动态数组的相关功能，我们需要将数组封装一层Array类。在Array类创建有参和无参构造，用于用户定义起始数组的大小。接下来就要实现其具体的增删改查四种功能：

1. 增
   add(int index, E e)向指定位置添加元素e。在执行添加操作前，需判断当前数组是否已经放满。如果放满，则需要扩容数组。（数组的扩容，采用哪种扩容机制？一次扩容太大浪费空间，一次扩容太小，会造成频繁扩容，影响性能。）而扩容数组也就是新建一个新的大容量数组，将旧数组中的数据放在新数组中，而旧的数组在后面没有使用（或者置空）就会被垃圾回收站回收。这样也就实现了数组的扩容。数组的空间够了后，需要向指定位置添加元素e。首先一点，肯定不能直接赋值，这样会覆盖之前数据。所以，我们需要先将index位置以及之后的元素都往后移，然后再将元素e赋值到index位置
2. 删
   remove(int index)从index位置删除元素，就是将index位置之后的元素都向前移动一位，这样就将index+1的位置元素赋值给index位置处，而index处原本的值被覆盖
3. 改
   set(int index,E e)直接将元素e赋值到index位置处
4. 查
   直接按照下标查询即可

代码的具体实现

package Array;

public class Array<E> {
	private static int capacity = 10;
	private E[] data;
	private int size;

	/**
	 * 传入数组容量，创建数组
	 * 
	 * @param capacity
	 */
	public Array(int capacity) {
		data = (E[])new Object[capacity];
		size = 0;
	}

	/**
	 * 无参数构造函数，默认数组容量capacity=10
	 */
	public Array() {
		this(capacity);
	}

	/**
	 * 获取数组中元素个数
	 */
	public int getSize() {
		return size;
	}

	/**
	 * 获取数组的容量
	 */
	public int getCapacity() {
		return data.length;
	}

	/**
	 * 判断数组是否为空
	 */
	public boolean isEmpty() {
		return size == 0;
	}

	/**
	 * 向所有元素后添加一个新元素
	 * 
	 * @param e
	 */
	public void addLast(E e) {
		add(size, e);
	}

	/**
	 * 在所有元素前添加一个新元素
	 */
	public void addFirst(E e) {
		add(0, e);
	}

	/**
	 * 向指定位置添加元素
	 * 
	 * @param index
	 * @param e
	 */
	public void add(int index, E e) {
		if (size == data.length) {
			resize(2*data.length);
		}
		if (index < 0 || index > size) {
			throw new IllegalArgumentException("AddList failed. Array is full");
		}
		for (int i = size - 1; i >= index; i--) {
			data[i + 1] = data[i];
		}
		data[index] = e;
		size++;
	}
	
	private void resize(int newCapacity) {
		E[] newData = (E[])new Object[newCapacity];
		for (int i = 0; i < size; i++) {
			newData[i] = data[i];
		}
		data = newData;
	}

	/**
	 *获取索引index位置的元素 
	 */
	E get(int index){
		if(index<0 || index >= size){
			throw new IllegalArgumentException("Get failed. Index is illegal.");
		}
		return data[index];
	}
	
	/**
	 * 修改index索引位置的元素
	 */
	void set(int index,E e){
		if(index<0 || index >= size){
			throw new IllegalArgumentException("Get failed. Index is illegal.");
		}
		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所在的索引，如果不存在，返回-1
	 * @param e
	 * @return
	 */
	public int find(E e){
		for (int i = 0; i < size; i++) {
			if(data[i].equals(e)){
				return i;
			}
		}
		return -1;
	}
	
	/**
	 * 从index位置删除元素，并将删除的元素返回
	 * @param index
	 * @return
	 */
	public E remove(int index){
		if(index<0 || index >= size){
			throw new IllegalArgumentException("Remove failed. Index is illegal.");
		}
		E ret = data[index];
		for (int i = index+1; i < size; i++) {
			data[i-1] = data[i];
		}
		size--;
		return ret;
	}
	
	/**
	 * 删除数组中第一个元素
	 * @return
	 */
	public E removeFirst(){
		return remove(0);
	}
	
	/**
	 * 删除数组中最后一个元素
	 * @return
	 */
	public E removeLast(){
		return remove(size-1);
	}
	
	/**
	 * 从数组中删除元素e
	 */
	public void removeElement(E e){
		int index = find(e);
		if(index != -1){
			remove(index);
		}
	}
	
	@Override
	public String toString() {
		StringBuilder res = new StringBuilder();
		res.append(String.format("Array: size = %d , capacity = %d\n", size, data.length));
		res.append("[");
		for (int i = 0; i < size; i++) {
			res.append(data[i]);
			if (i != size - 1) {
				res.append(", ");
			}
		}
		res.append("]");
		return res.toString();
	}
}

代码中丰富了一些方法，重写了个toString

验证

结论

简单的时间复杂度分析
O(1)，O(n)，O(lgn)，O(nlogn)，O(n^2)一般分为这几种复杂度
大O描述的是算法的运行时间和输入数据之间的关系，举个栗子说明如下：

public static int sun(int[] nums){
	int sun = 0;
	for(int num:nums){
		sun+=num;
	}
	return sun;
}

上面一串简单的代码，就是求数组中数字之和。而这段程序运行的时间是与入参的数组中数据个数有关。100个数之和与10万个数之和，所花费的时间肯定不一样！这个程序的时间复杂度就是O(n)级别。其中n可以理解为入参数组的个数，程序所运行的时间是随着n值的增加而增加，算法与n呈线性关系。
分析动态数组的时间复杂度
动态数组中，查询、修改，直接通过下标即可实现，与数组中size大小没有关系，所以时间复杂度为O(1)
动态数组中，新增、删除，需要遍历数组，当数组size大时，遍历时间也就越长，所以时间复杂度为O(n)