ArrayList构造方法详细信息

流程

1.新建一个project
2.在建立两个 .class 文件List.class和ArrayList.class。

//list.class
public interface List<T> extends Iterable<T> {
    int size();
    boolean isEmpty();
    int indexOf(int index,T t);
    int indexOf(T t);
    int lastIndexOf(T t);
    boolean add(T t);
    boolean add(int index, T t);
    boolean add(List<T> list);
    boolean add(int index, List<T> list);
    boolean remove(T t);
    T remove(int index);
    boolean remove(List<T> list);
    void retain(List<T> list);
    boolean set(int index, T t);
    T get(int index);
    boolean contains(T t);
    boolean contains(List<T> list);
    default  boolean isIndexValid(int index,boolean add){
        return index>=0&&(add? index<=size():index<size());
    }
   Iterable<T>iterable();

}

//ArrayList
public class ArrayList<T>implements List<T> {
    private Object[] elements;
    private int size;//新元素下标，现有元素的数量
    private final  Object[] EMRTY={};//空数组
    private Object[] copy;//扩充容量，临时存储元数组

    public ArrayList(){
        elements= EMRTY;
    }
    public ArrayList(int initCapacity){
       // elements=new Object[initCapacity<0? CK_C_INITIALIZE_ARGS:];
    }


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

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

    public int indexOf(int index,T t){
        if(!isIndexValid(index,false)){
            return -1;
        }
        int _index=-1;
        for (int i =  size-1;  i >=0; i--) {
            if(t.equals(elements[i])){

            }
        }
        return _index;
    }
    private  List<Integer> _indexOf(T t){
        List<Integer> list=new ArrayList();
        int i=0;
        while(i<size){
           int index=indexOf(i,t);
           if(index!=-1){
               list.add(index);
               i=index+1;
           }
        }
        return list;
    }
    @Override
    public int indexOf(T t) {
       return indexOf(0,t);
    }

    @Override
    public int lastIndexOf(T t) {
        return 0;
    }

    private void ensureCapacity(int count){
        if(elements.length-size>count){return;}
        copy=elements;
        elements=new Object[(size+count)*2];
        for (int i = 0; i <size; i++) {
            elements[i]=copy[i];
            copy[i]=null;
        }
        copy=EMRTY;
    }
    private void reduceCapaciity(){
        if(size*1.0/elements.length>0.25){
            return;
        }
        copy=elements;
        elements=new Object[copy.length/2];
        for (int i = 0; i <size; i++) {
            elements[i]=copy[i];
            copy[i]=null;
        }
        copy=EMRTY;
    }
    @Override
    public boolean add(T t) {
        //扩充容量
        ensureCapacity(1);
        elements[size++]=t;
        return true;
    }

    @Override
    public boolean add(int index, T t) {
        if(!isIndexValid(index,true)) {
            return false;
        }
        ensureCapacity(1);
        for (int i = size; i >index ; i--) {
            elements[i]=elements[i-1];
        }
          elements[index]=t  ;
        size++;
        return  true;
    }

    @Override
    public boolean add(List<T> list) {
        for (T t : list) {
            add(t);
        }
        return true;
    }

    @Override
    public boolean add(int index, List<T> list) {
        if(!isIndexValid(index,true)){
            return false;
        }
        int _size=list.size();
       ensureCapacity( _size);
        for (int i = size-1; i >=index ; i--) {
          elements[i+ _size]=elements[i];
        }
        for(int i=0;i<size;i++){
            elements[index++]=list.get(i);
        }
        size+=_size;
        return  true;
    }

    @Override
    public boolean remove(T t) {
        List<Integer>ixs=_indexOf(t);
        if(ixs.size()==0){
            return false;
        }
        for (Integer ix : ixs) {
           remove(ix);
        }
        return true;
    }

    @Override
    public T remove(int index) {
        if(isIndexValid(index,false)){
            for(int i=index;i<size;i++){
                elements[i]=elements[i+1];
            }
        }
        return null;
    }

    @Override
    public boolean remove(List<T> list) {
        return false;
    }

    @Override
    public void retain(List<T> list) {
        List<T>retain =new ArrayList<>();
        List<Integer> ixs=new ArrayList<>();
        for (T t : list) {
           ixs.add(_indexOf(t)) ;
        }
        if(ixs.size()>0) {
            copy = new Object[ixs.size()];
            int size=0;
            for(Integer ix:ixs){

            }
        }
    }

    @Override
    public boolean set(int index, T t) {

        return false;
    }

    @Override
    public T get(int index) {
        if(isIndexValid(index,false)){
            return (T)elements[index];
        }
        return null;
    }

    @Override
    public boolean contains(T t) {
        return false;
    }

    @Override
    public boolean contains(List<T> list) {
        for (T t : list) {
           if(!contains(t)){
               return false;
           }
        }
        return true;
    }

    @Override
    public boolean isIndexValid(int index, boolean add) {
        return false;
    }

    @Override
    public Iterable<T> iterable() {
        return null;
    }

    @Override
    public Iterator<T> iterator() {

        return new Iterator<T>() {
            private  int iteratorIndex=0;
            @Override
            public boolean hasNext() {
                return iteratorIndex<size;
            }

            @Override
            public T next() {
                return (T)elements[iteratorIndex++];
            }
        };
    }
}