JAVA数据结构ArrayList实现

package p01.动态数组;

public interface List<E> {
	public int getSize();			//获取列表中元素的个数
	public boolean isEmpty();		//判断当前列表是否为空
	public void add(int index, E e);//在列表中指定角标index处，添加元素e
	public void addFrist(E e);		//在列表第一个位置添加e
	public void addLast(E e);		//在列表最后一个位置添加e
	public E get(int index);		//获取index角标位置的元素
	public E getFrist();			//获取列表中第一个元素
	public E getLast();				//获取列表中最后一个元素
	public E remove(int index);		//删除index处的元素并返回元素
	public E removeFrist();			//删除列表中的第一个元素，并返回
	public E removeLast();			//删除列表中的最后一个元素，并返回
	public void set(int index,E e);	//修改index处的元素为e
	public boolean contains(E e);	//判断列表是否包含e
	public int find(E e);			//在列表中查找指定元素e的角标
	public void removeElement(E e);	//在列表中删除指定元素e
	public void clear();
}

package p01.动态数组;

//动态数组实现的链表->顺序表
/*List
 * --ArrayList
 * 增删O(n) 改查O(1)
 */
public class ArrayList<E> implements List<E> {
	private E[] data;	//容器-存储元素 data.length 最大容量
	private int size;	//当前列表中元素的个数   有效长度
	private static final int DEFAULT_CAPACITY=10;
	public ArrayList(){	//默认构造函数创建一个容量为10的列表
		this(DEFAULT_CAPACITY);
	}
	public ArrayList(int capacity){//构造函数中创建一个容量为capacity的列表
		if(capacity<0){
			capacity=DEFAULT_CAPACITY;
		}
		this.data=(E[]) new Object[DEFAULT_CAPACITY];
		this.size=0;
	}
	//O(n)
	@Override
	public void add(int index,E e){
		if(index<0||index>size){
			throw new IllegalArgumentException("角标越界");
		}
		if(size==data.length){
			resize(data.length*2); //重置容量
		}
		for(int i=size;i>index;i--){
			data[i]=data[i-1];
		}
		data[index]=e;
		size++;
	}
	//O(n)
	@Override
	public void addFrist(E e) {
		add(0, e);
		
	}
	//O(1)
	@Override
	public void addLast(E e) {
		add(size,e);
	}
	//O(n)
		@Override
		public E remove(int index) {
			if(index<0||index>=size){
				throw new IllegalArgumentException("角标越界");
			}
			E res=data[index];
			for(int i=index;i<size-1;i++){
				data[i]=data[i+1];
			}
			size--;
			if(size==data.length/4 && data.length>DEFAULT_CAPACITY){
				resize(data.length/2);
			}
			return res;
		}
	//O(n)
	@Override
	public E removeFrist() {
		return remove(0);
	}
	//O(1)
	@Override
	public E removeLast() {
		return remove(size-1);
	}
	@Override
	public void removeElement(E e) {
		int index=find(e);//O(n)
		if(index!=-1){
			remove(index);//O(n)
		}
	}
	
	//O(n)
	private void resize(int newLen) {
		E[] newData=(E[]) new Object[newLen];
		for(int i=0;i<Math.min(data.length, newData.length);i++){
			newData[i]=data[i];
		}
		data=newData;
	}
	//O(1)
	@Override
	public int getSize() {
		return this.size;
	}
	//O(1)
	@Override
	public boolean isEmpty() {
		return this.size==0;
	}
	//O(1)
	@Override
	public E get(int index) {
		if(index<0||index>=data.length){
			throw new IllegalArgumentException("index is out of data!");
		}
		return data[index];
	}
	@Override
	public E getFrist() {
		// TODO 自动生成的方法存根
		return get(0);
	}
	@Override
	public E getLast() {
		// TODO 自动生成的方法存根
		return get(size-1);
	}
	//O(1)
	@Override
	public void set(int index, E e) {
		if(index<0||index>=size){
			throw new IllegalArgumentException("index is out of data!");
		}
		data[index]=e;
	}
	//O(n)
	@Override
	public int find(E e) {
		for (int i = 0; i < size; i++) {
			if(data[i]==e){
				return i;
			}
		}
		return -1;
	}
	@Override
	public boolean contains(E e) {
		// TODO 自动生成的方法存根
		return find(e)!=-1;
	}
	public int getCapacity(){
		return data.length;
	}
	@Override
	public void clear() {
		this.data=(E[]) new Object[DEFAULT_CAPACITY];
		this.size=0;
	}
	public void swap(int i,int j){
		if(i<0||i>=size||j<0||j>=size){
			throw new IllegalArgumentException("角标非法");
		}
		E temp=data[i];
		data[i]=data[j];
		data[j]=temp;
	}
	
	@Override
	public String toString() {
		StringBuilder sb=new StringBuilder();
		if(isEmpty()){
			//ArrayList:[] 0/10
			sb.append(String.format("ArrayList:[] %d/%d\n", size,data.length));
		}else{
			sb.append("[");
			for(int i=0;i<size;i++){
				if(i==size-1){
					sb.append(data[i]+"]");
				}else{
					sb.append(data[i]+",");
				}
			}
			sb.append(String.format("ArrayList: %d/%d \n", size,data.length));
		}
		return sb.toString();
	}
}