MyArrayList

package soul.demo.lists;

import java.util.*;

class MyArrayList<E> implements List<E>{
    
    public static void main(String[] args){
        
    }
    
    //空列表
    private final static Object[] EMPTY_ELEMENTDATA={};
    
    //存储元素的Object数组
    private Object[] elementData;
    
    //默认容量
    private final static int DEFAULT_CAPACITY=10;
    
    //容量大小（实际存储的元素数量，默认为0）
    private int size=0;
    
    /**
     * 构造一个初始容量为initCapacity的空列表
     * @param initCapacity
     */
    public MyArrayList(int initCapacity){
        if(initCapacity>0)
            elementData=new Object[initCapacity];
        else if(initCapacity==0)
            elementData=EMPTY_ELEMENTDATA;
        else
            throw new IllegalArgumentException("Illegal Capacity: "+
                    initCapacity);
    }
    
    /**
     * 构造一个初始容量为10的空列表
     */
    public MyArrayList(){
        elementData=new Object[DEFAULT_CAPACITY];
    }
    
    /**
     * 构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的
     * @param c
     */
    public MyArrayList(Collection<? extends E> c){
        if(c.size()>0){
            elementData=new Object[c.size()];
            addAll(c);
        }
        else
            elementData=EMPTY_ELEMENTDATA;
    }
    @Override
    /**
     * 返回列表中的元素数
     */
    public int size() {
        // TODO Auto-generated method stub
        return this.size;
    }

    @Override
    /**
     * 若列表中不包含元素，则返回true
     */
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return this.size==0;
    }

    @Override
    /**
     * 如果列表包含指定的元素，则返回true
     */
    public boolean contains(Object o) {
        // TODO Auto-generated method stub
        return indexOf(o)>0;
    }

    @Override
    /**
     * 返回按适当顺序在列表上进行迭代的迭代器
     */
    public Iterator<E> iterator() {
        // TODO Auto-generated method stub
        return new Itr<E>();
    }
    @SuppressWarnings("hiding")
    private class Itr<E> implements Iterator<E>{

        private int index=0;
        @Override
        public boolean hasNext() {
            // TODO Auto-generated method stub
            return index!=size;
        }

        @SuppressWarnings("unchecked")
        @Override
        public E next() {
            // TODO Auto-generated method stub
            return (E)elementData[index++];
        }
        
    }
    @Override
    /**
     * 返回按适当顺序包含列表中所有元素的数组
     */
    public Object[] toArray() {
        // TODO Auto-generated method stub
        Object[] arrElementData=new Object[size]; 
        System.arraycopy(elementData, 0, arrElementData, 0, size);
        return arrElementData;
    }

    @Override
    /**
     * 尽可能的将列表中的元素存储在数组a中；返回数组的运行时类型是指定数组的运行时类型。
     */
    public <T> T[] toArray(T[] a) {
        // TODO Auto-generated method stub
        
        if(a.length>=size){
            System.arraycopy(elementData, 0, a, 0, size);
        }else{
            System.arraycopy(elementData, 0, a, 0, a.length);
        }
        return a;
    }

    @Override
    /**
     * 向列表的尾部添加指定的元素
     * 
     * @param 
     * @return 
     */
    public boolean add(E e) {
        // TODO Auto-generated method stub
        if(size==elementData.length)
            growCapacity();
        elementData[size++]=e;
        return true;
    }

    @Override
    /**
     * 从列表中移除第一次出现的指定元素(若存在)
     */
    public boolean remove(Object o) {
        // TODO Auto-generated method stub
        int index=indexOf(o);
        if(index>=0)
            return remove_0(index);
        else 
            return false;
    }

    private boolean remove_0(int index) {
        // TODO Auto-generated method stub
        System.arraycopy(elementData, index+1, elementData, index, size-index-1);
        elementData[--size]=null;
        return true;
    }

    @Override
    /**
     * 如果列表包含指定collection中的所有元素，则返回true
     */
    public boolean containsAll(Collection<?> c) {
        // TODO Auto-generated method stub
        Iterator<?> iterator=c.iterator();
        Object obj;
        while((obj=iterator.next())!=null){
            if(indexOf(obj)<0)
                return false;
        }
        return true;
    }

    @Override
    /**
     * 添加指定Collection中的元素到此列表的结尾，顺序是指定的Collection迭代器返回的顺序
     */
    public boolean addAll(Collection<? extends E> c) {
        // TODO Auto-generated method stub
        return addAll(size+1,c);
    }

    @Override
    /**
     * 将指定的collection中的所有元素插入列表的指定位置
     */
    public boolean addAll(int index, Collection<? extends E> c) {
        // TODO Auto-generated method stub
        int _size=size;
        size+=c.size();
        Object[] source=c.toArray();
        if(elementData.length<size)
            growCapacity(c.size());        
        if(index<_size+1){
            Object[] trasientArr=new Object[_size-index];
            System.arraycopy(elementData, index, trasientArr, 0, size-index);
            System.arraycopy(trasientArr, 0, elementData, index+c.size(), trasientArr.length);
        }
        System.arraycopy(elementData, index, source, 0,c.size() );
        return true;
    }

    @Override
    /**
     * 从列表中移除指定collection的所有元素
     * 思路是将不需要remove的元素单独取出来
     */
    public boolean removeAll(Collection<?> c) {
        // TODO Auto-generated method stub
        return batchRemove(c,false);
    }

    @Override
    /**
     * 仅在列表中保留指定collection的所有元素
     */
    public boolean retainAll(Collection<?> c) {
        // TODO Auto-generated method stub
        return batchRemove(c,true);
    }

    private boolean batchRemove(Collection<?> c,boolean isRemove){
        
        Object tempStore[]=new Object[size];
        int ts=0;
        
        for(int i=0;i<size;i++){
            if(c.contains(elementData[i])==isRemove)
                tempStore[ts++]=elementData[i];
        }
        System.arraycopy(tempStore, 0, elementData, 0, ts);
        size=ts-1;
        return true;
    }
    @Override
    /**
     * 从列表中移除移除所有元素
     */
    public void clear() {
        // TODO Auto-generated method stub
        for(int i=0;i<size;i++)
            elementData[size]=null;
        size=0;
    }

    @SuppressWarnings("unchecked")
    @Override
    /**
     * 返回列表中指定位置的元素
     */
    public E get(int index) {
        // TODO Auto-generated method stub
        rangeCheck(index);
        return (E)elementData[index];
    }

    @SuppressWarnings("unchecked")
    @Override
    /**
     * 用指定元素在替换指定位置的元素
     */
    public E set(int index, E element) {
        // TODO Auto-generated method stub
        rangeCheck(index);
        E oldValue=(E)elementData[index];
        elementData[index]=element;
        return oldValue;
    }

    @Override
    /**
     * 在列表的指定位置插入指定元素
     */
    public void add(int index, E element) {
        // TODO Auto-generated method stub
        rangeCheck(index);
        if(size==elementData.length)
            growCapacity();
        System.arraycopy(elementData, index, elementData, index+1, size-index);
        elementData[index]=element;
        size++;
    }

    @SuppressWarnings("unchecked")
    @Override
    /**
     * 移除列表中指定位置的元素
     */
    public E remove(int index) {
        // TODO Auto-generated method stub
        rangeCheck(index);
        E oldValue=(E)elementData[index];
        remove_0(index);
        return oldValue;
    }

    @Override
    /**
     * 返回此列表中第一次出现指定元素的指引，若列表不包含该元素，则返回-1
     */
    public int indexOf(Object o) {
        // TODO Auto-generated method stub
        if(o==null){
            for(int i=0;i<size;i++){
                if(elementData[i]==null)
                    return i;
            }
        }else{
            for(int i=0;i<size;i++){
                if(o==elementData[i])
                    return i;
            }    
        }

        return -1;
    }

    @Override
    /**
     * 返回列表中指定元素最后出现的位置，若列表不包含该元素，则返回-1
     */
    public int lastIndexOf(Object o) {
        // TODO Auto-generated method stub
        int goal=-1;
        if(o==null){
            for(int i=0;i<size;i++){
                if(elementData[i]==null)
                    goal=i;
            }
        }else{
            for(int i=0;i<size;i++){
                if(o==elementData[i])
                    goal=i;;
            }    
        }

        return goal;
    }

    @Override
    /**
     * 返回此列表元素的列表迭代器
     */
    public ListIterator<E> listIterator() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    /**
     * 返回列表元素的列表迭代器，从列表的指定位置开始
     */
    public ListIterator<E> listIterator(int index) {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    /**
     * 返回列表中指定索引之间的部分视图
     */
    public List<E> subList(int fromIndex, int toIndex) {
        // TODO Auto-generated method stub
        return null;
    }
    
    /**
     * 比较指定的对象与列表是否相等
     */
    public boolean equals(Object obj){
        return false;
    }
    
    /**
     * 返回列表的哈希码值
     */
    public int hashCode(){
        return 0;
    }
    
    /**
     * 增加容量
     */
    private void growCapacity(){
        growCapacity(elementData.length>>1);
    }
    
    private void growCapacity(int addLen){
        int oldLen=elementData.length;
        int newLen=(int)(oldLen+addLen);
        Object[] newElementData=new Object[newLen];
        System.arraycopy(elementData, 0, newElementData, 0, oldLen);
        elementData=newElementData;
    }
    
    /**
     * 检查index是否超出列表范围
     * @param index
     */
    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
    private String outOfBoundsMsg(int index) {
        return "Index: "+index+", Size: "+size;
    }
    
    public String toString(){
        String str="[";
        for(int i=0;i<size;i++){
            if(i==size-1)
                str+=elementData[i];
            else
                str+=elementData[i]+",";
            
        }
        return str+"]";
    }
}