自定义ArrayList

与ArrayList同名，注意导包问题，实现之前自定义的List接口

代码中方法皆有注释，注意查看

import java.util.Comparator;
import java.util.Iterator;

/**
 * 线性结构的顺序存储实现方式
 * */
public class ArrayList<E> implements List<E> {
    //存储元素的容器
    private E[] data;
    //元素的有效个数
    private int size;
    //默认容量大小
    private static int DEFAULT_CAPACITY = 10;

    /**
     * 创建一个默认容量为10的线性表
     * */
    public ArrayList() {
    	
        this(DEFAULT_CAPACITY);
    }
    /**
     * 创建一个容量为指定值capacity的线性表
     * */
    public ArrayList(int capacity) {
    	
        if (capacity <= 0) {
        	
            throw new IllegalArgumentException("initial capacity must > 0");
        }
        
        data = (E[]) new Object[capacity];
        size = 0;
    }
    /**
     * 将一个现有的数组封装成一个线性表
     * */
    public ArrayList(E[] arr) {
    	
        if (arr == null) {
        	
            throw new IllegalArgumentException("initial arr can not be null");
        }
        
        data = (E[]) new Object[arr.length];
        size = 0;
        for (E e : arr) {
            add(e);
        }
    }

    @Override
    public void add(E element) {
    	
        add(size,element);
    }

    @Override
    public void add(int index, E element) {
    	
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("add index must 0 <= index <= size");
        }
        //是否满了
        if (size == data.length) {
            //扩容
            resize(data.length * 2);
        }
        for (int i = size; i > index; i--) {
            data[i] = data[i - 1];
        }
        data[index] = element;
        size++;
    }

    private void resize(int newLength) {
    	
        E[] newData = (E[]) new Object[newLength];
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }

    @Override
    public void remove(E element) {
    	
        int index = 0;
        
        while ((index = indexOf(element)) != -1) {
            remove(index);
        }
    }

    @Override
    public E remove(int index) {
    	
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("remove index must 0 <= index < size");
        }
        E ret = data[index];
        for (int i = index ; i <= size - 2; i++) {
            data[i] = data[i + 1];
        }
        size--;
        if (size == data.length / 4 && data.length > DEFAULT_CAPACITY) {
            resize(data.length / 2);
        }
        return ret;
    }

    @Override
    public E get(int index) {
    	
        if (index < 0 || index >= size) {
        	
            throw new IllegalArgumentException("get index outof range");
        }
        return data[index];
    }

    @Override
    public E set(int index, E element) {
    	
        if (index < 0 || index >= size) {
        	
            throw new IllegalArgumentException("get index outof range");
        }
        E ret = data[index];
        data[index] = element;
        return ret;
    }

    @Override
    public int size() {
    	
        return size;
    }

    @Override
    public int indexOf(E element) {
    	
        for (int i = 0; i < size; i++) {
        	
            if (data[i].equals(element)) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public boolean contains(E element) {
    	
        return indexOf(element) != -1;
    }

    @Override
    public boolean isEmpty() {
    	
        return size == 0;
    }

    @Override
    public void clear() {
    	
        data = (E[]) new Object[DEFAULT_CAPACITY];
        size = 0;
    }

    @Override
    public void sort(Comparator<E> comparator) {
    	//插入排序o(n*n)
    	if(comparator==null) {
    		
    		throw new IllegalArgumentException("comparator can not be null");
    	}
    	
    	for(int i=1;i<size;i++) {
    		
    		E e=data[i];
    		
    		int j;
    		
    		for( j=i;j>0&&comparator.compare(data[j-1], e)>0;j--) {
    			
    			data[j]=data[j-1];
    		}
    		
    		data[j]=e;
    	}
    	 

    }

    @Override
    public List<E> sublist(int fromIndex, int toIndex) {
    	
    	if(fromIndex<0||toIndex>size||fromIndex>toIndex) {
    		
    		throw new IllegalArgumentException("sublist index out range");
    	}
    	ArrayList<E> list =new ArrayList<>();
    	
    	for(int i=fromIndex;i<toIndex;i++) {
    		
    		list.add(data[i]);;
    	}
        return list;
    }

    @Override
    public String toString() {
    	
    	StringBuilder sb =new StringBuilder();
    	
    	sb.append('[');
    	
    	if(isEmpty()) {
    		
    		sb.append(']');
    		
    	}else {
    		
    		for(int i=0;i<size;i++) {
    			
    			sb.append(data[i]);
    			
    			if(i!=size-1) {
    				
    				sb.append(',');
    				
    			}else {
    				
    				sb.append(']');
    			}
    		}
    	}
    	
        return sb.toString();
    }

    @Override
    public boolean equals(Object obj) {
    	
    	if(obj==null) {
    		
    		return false;
    	}
    	if(obj==this) {
    		
    		return true;
    	}
    	if(obj instanceof ArrayList) {
    		
    		ArrayList<E > other =(ArrayList<E>) obj;
    		
    		if(this.size==other.size) {
    			
    			for(int i=0;i<size;i++) {
    				
    				if(!this.data[i].equals(other.data[i])) {
    					
    					return false;
    				}
    			}
    		}
    		
    	}else {
    		
    		return false;
    	}
        return false;
    }

    //返回迭代器对象
    @Override
    public Iterator<E> iterator() {
    	
    	
      return new ArrayListIterator();
    }
    
    private class ArrayListIterator implements Iterator<E>{
    	
    	
          int cur=0;

		@Override
		public boolean hasNext() {//判断是否有下一个元素
			
			return cur<size;
		}

		@Override
		public E next() {//取出当前元素并跳到下一个元素
			
			return data[cur++];
		}
    	
    }
}