数组

数组

数组，是有序的元素序列。支持快速查询，但删除非常麻烦。

实现原理有两点：

1. 能够自动扩容和缩容。
2. 能够存放不同类型的数据。(使用泛型)

首先，我先介绍如何实现存放不同类型的数据。

public class Array<E> {
}

在创建类的时候使用泛型，将数据类型传入。在方法中参数类型改变为泛型。如下：

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

泛型创建数组时，因为java不能使用泛型直接new数组(new E[])。必须使用object进行强制类型转换。

/**
	 * 构造函数 传入数组的容量为capacity构造array
	 */
	public Array(int capacity) {
		//由于历史原因 只能new object类型的数组
		data = (E[])new Object[capacity];
		size = 0;
	}

实现自动扩容：

在添加数组元素的时候，进行判断。

    /**
	 * 向指定位置添加元素
	 */
	public void add(int index, E e) {
		// 大于size创建的数组不紧凑
		if (index < 0 && index > size)
			throw new IllegalArgumentException("AddLast failed, array is full");
		if (size == data.length)
			resize(2 * data.length);
		for (int i = size; i > index; i--) {
			data[i] = data[i - 1];
		}
		data[index] = e;
		size++;
	}

实现自动缩容

在删除数组元素的时候进行判断。

/**
	 * 删除下标为 index的元素 返回删除元素
	 * @param index
	 */
	public E remove(int index) {
		if (index < 0 && index >= size)
			throw new IllegalArgumentException("AddLast failed, array is full");
		E ret = data[index];
		for(int i = index; i< size-1;i++) {
			data[i] = data[i+1];
		}
		size--;
		data[size] = null;
		//进行判断 如果数组元素等于容量的一半 则缩容
		if(size == data.length/2) {
			resize(data.length/2);
		}
		return	ret;
	}

以下为数组的实现(源码)：

package array;

public class Array<E> {
	private E[] data;
	private int size;

	/**
	 * 构造函数 传入数组的容量为capacity构造array
	 */
	public Array(int capacity) {
		//由于历史原因 只能new object类型的数组
		data = (E[])new Object[capacity];
		size = 0;
	}

	/**
	 * 无参的构造函数 数组长度默认为10
	 */
	public Array() {
		data =(E[])new Object[10];
	}

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

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

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

	/**
	 * 向数组中添加元素
	 */
	public void addLast(E e) {
		add(size, e);
	}

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

	/**
	 * 向指定位置添加元素
	 */
	public void add(int index, E e) {
		// 大于size创建的数组不紧凑
		if (index < 0 && index > size)
			throw new IllegalArgumentException("AddLast failed, array is full");
		if (size == data.length)
			resize(2 * data.length);
		for (int i = size; i > index; i--) {
			data[i] = data[i - 1];
		}
		data[index] = e;
		size++;
	}

	

	@Override
	public String toString() {
		StringBuilder res = new StringBuilder();
		res.append("Array size =" + size + ",capacity=" + data.length + "\n");
		res.append("[");
		for (int i = 0; i < size; i++) {
			res.append(data[i]);
			if (i != size - 1) {
				res.append(",");
			}
		}
		res.append("]");
		return res.toString();
	}

	/**
	 * 
	 * 获取index位置的元素
	 */
	public E get(int index) {
		if (index < 0 && index >= size)
			throw new IllegalArgumentException("AddLast failed, array is full");
		return data[index];
	}

	/**
	 * 修改index索引的元素为e
	 */
	public void set(int index, E e) {
		if (index < 0 && index >= size)
			throw new IllegalArgumentException("AddLast failed, array is full");
		data[index] = e;
	}

	/**
	 * 查询是否包含某元素
	 */
	public boolean contains(E e) {
		for (int i = 0; i < size; i++) {
			if (data[i].equals(e)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 查找数组元素的下标 存在返回下标 不存在返回-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
	 */
	public E remove(int index) {
		if (index < 0 && index >= size)
			throw new IllegalArgumentException("AddLast failed, array is full");
		E ret = data[index];
		for(int i = index; i< size-1;i++) {
			data[i] = data[i+1];
		}
		size--;
		data[size] = null;
		//进行判断 如果数组元素等于容量的一半 则缩容
		if(size == data.length/4 && data.length/4 ！= 0) {
			resize(data.length/2);
		}
		return	ret;
	}
	/**
	 * 删除数组中第一个元素 返回删除元素
	 * @return
	 */
	public E removeFirst() {
		return	remove(0);
	}
	
	/**
	 * 删除数组最后一个元素 返回删除元素
	 */
	public E removeLast() {
		return	remove(size-1);
	}
	
	/**
	 * 判断数组中是否存在某个元素
	 * 存在 则删除 
	 */
	public void removeElement(E e) {
		int index = find(e);
		if(index != -1) {
			remove(index);
		}
	}
	/**
	 * 给数组扩容为2倍
	 * @param i
	 */
	private void resize(int newCapacity) {
		E[] newData = (E[]) new Object[newCapacity];
		for (int i = 0; i < size; i++) {
			newData[i]=data[i];
		}
		data = newData;
	}
}