自定义数组

通过学习自定义数组，了解数组的数据结构。

package algorithm;

public class Array<E> {
	private E[] data;
	private int size;//数组的实际大小
	/**
	 * 无参的构造函数，默认初始容量
	 */
	public Array() {
		this(10);//默认初始容量为10
	}
	/**
	  * 带参的构造函数，创建数组
	 * @param capacity  传入的数组容量 
	 */
	public Array(int capacity) {
		data=(E[]) new Object[capacity];
	}
	
	/**
	 * 获取数组容量
	 */
	public int getCapacity() {
		return data.length;
	}
	/**
	 * 获取数组实际大小
	 */
	public int getSize() {
		return size;
	}
	/**
	 * 判断数组是否为空
	 * @return 
	 */
	public boolean isEmpty() {
		return size==0;
	}
	/**
	 * 在指定索引位置，添加元素
	 * @param index 指定索引
	 * @param e   新元素
	 */
	public void add(int index, E e) {
		if(index<0 || index>size) {
			throw new RuntimeException("faied...");
		}
		if(size==data.length) {
			resize(2*data.length);
		}
		for(int i=size-1;i>=index;i--) {
			data[i+1]=data[i];
		}
		
		data[index]=e;
		size++;
	}
	/**
	 * 在最后添加一个元素
	 * @param e
	 */
	public void addLast(E e) {
		add(size,e);
	}
	/**
	 * 在最前添加一个元素
	 * @param e
	 */
	public void addFirst(E e) {
		add(0,e);
	}
	/**
	 *  获取指定位置的元素
	 * @param index  索引位置
	 * @return  返回该元素
	 */
	public E get(int index) {
		if(index<0 || index>=size) {
			throw new RuntimeException("faied...");
		}
		return data[index];
	}
	/**
	 * 修改指定位置的元素
	 * @param index
	 * @param e
	 */
	public void set(int index, E e) {
		if(index<0 || index>=size) {
			throw new RuntimeException("faied...");
		}
		data[index]=e;
	}
	/**
	 * 查找数组中是否有指定元素
	 * @param e
	 * @return
	 */
	public boolean contains(E e) {
		for(E d:data) {
			if(d.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;
	}
	/**
	 * 删除数组中指定位置的索引。并返回删除的元素。
	 * @param index
	 * @return
	 */
	public E remove(int index) {
		if(index<0 || index>=size) {
			throw new RuntimeException("faied...");
		}
		E e=data[index];
		for(int i=index+1;i<size;i++) {
			data[i-1]=data[i];
		}
		data[size-1]=null;//游离数据，清除掉
		size--;
		if(size == data.length / 4 && data.length / 2 != 0)
            resize(data.length / 2);
		return e;
	}
	/**
	 * 删除第一个元素，并返回该元素
	 * @return
	 */
	public E removeFirst() {
		return remove(0);
	}
	/**
	 * 删除最后一个元素，并返回该元素
	 * @return
	 */
	public E removeLast() {
		return remove(size-1);
	}
	/**
	 * 从数组中删除指定元素
	 * @param e
	 */
	public void removeElement(E e) {
		int index=find(e);
		if(index!=-1) {
			remove(index);
		}
	}
	/**
	 * 动态扩容
	 * @param newCapacity 新的容量
	 */
	private void resize(int newCapacity) {
		E[] newData=(E[])new Object[newCapacity];
		for(int i=0;i<size;i++) {
			newData[i]=data[i];
		}
		data=newData;
	}
	/**
	 * 重写的toString方法
	 */
	@Override
	public String toString() {
		StringBuilder sb=new StringBuilder();
		sb.append(String.format("Array:size=%d,capacity=%d\n", size,data.length));
		sb.append("[");
		for(int i=0;i<size;i++) {
			sb.append(data[i]);
			if(i!=size-1) {
				sb.append(",");
			}
		}
		sb.append("]");
		return sb.toString();
	}
	
	
	
}

测试类：

 

package algorithm;

public class Test {

	public static void main(String[] args) {
		Array<Integer> a=new Array<Integer>();
		for(int i=0;i<a.getCapacity();i++) {
			a.addLast(i);
		}
		System.out.println(a);
		
		a.add(1, 100);
        System.out.println(a);
        
        a.addFirst(-1);
        System.out.println(a);
        
       
        for(int i = 0 ; i <7 ; i ++){
            a.removeFirst();
            System.out.println(a);//此时会缩容
        }
	}

}

 

控制台输出结果：