自己实现ArrayList

package learn.java.collection;

import java.util.*;

public class MyArrayList {
    public static  void main(String [] args){
        ArrayLis<Integer> aList=new ArrayLis<Integer>();
        aList.add(2);
        aList.add(7);
        aList.add(1);
        System.out.println(aList.get(0));
        System.out.println(aList.size());
        System.out.println(aList.isEmpty());
        System.out.println(aList.contains("2"));
        System.out.println(aList.contains(7));
        System.out.println(aList.remove(2));
        System.out.println(aList.contains(1));
//        aList.set(2,6);
        aList.set(1,6);
        System.out.println(aList.indexOf(6));
        Object[] arr=aList.toArray();
        System.out.println(Arrays.toString(arr));
    }
}

class ArrayLis <T> implements List <T>{
    private T[] listArr;
    private int size;
    public ArrayLis()
    {
        listArr=(T[])new Object[10];
        size=0;
    }


    public void ensureCapacity(int minCapcity){
        int currentCapacity=listArr.length;
        if(minCapcity>currentCapacity){
            T[] oldlistArr=listArr;
            listArr=(T[])new Object[minCapcity];
            for(int i=0;i<size;i++)
                listArr[i]=oldlistArr[i];
            oldlistArr=null;
        }
    }


    public void rangeCheck(int index,String msg,int upperBound){
        if(index<0||index>=upperBound+1)
            throw new IndexOutOfBoundsException("\n"+msg+":index"+index+"out of bounds");
    }


    public void add(int index, T item){
        rangeCheck(index,"Arraylist add()",size);
        if (listArr.length==size)
            ensureCapacity(2*listArr.length);
        for(int j=size-1;j>=index;j--){
            listArr[j+1]=listArr[j];
        }
        listArr[index]=item;
        size++;
    }

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

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

    @Override
    public boolean contains(Object o) {
        for(int i=0;i<size;i++)
            if(listArr[i]==o)
                return true;
        return false;
    }

    @Override
    public Iterator<T> iterator() {
        return null;
    }

    @Override
    public Object[] toArray() {
        return Arrays.copyOf(listArr,size);
    }

    @Override
    public <T1> T1[] toArray(T1[] a) {
        return Arrays.copyOf(a,size);
    }

    @Override
    public boolean add(T t) {
        add(size,t);
        return true;
    }

    @Override
    public boolean remove(Object o) {
        int i;
        for( i=0;i<size;i++)
            if(listArr[i]==o)
                break;
        if(i==size)
            return false;
        for(int j=i-1;j<size;j++)
            listArr[j]=listArr[j+1];
        size--;
        return true;

    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean addAll(Collection<? extends T> c) {
        return false;
    }

    @Override
    public boolean addAll(int index, Collection<? extends T> c) {
        return false;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return false;
    }

    @Override
    public void clear() {

    }

    @Override
    public T get(int index) {
        return listArr[index];
    }

    @Override
    public T set(int index, T element) {
        rangeCheck(index ,"set index",size-1);
        listArr[index]=element;
        return element;
    }

    @Override
    public T remove(int index) {

        rangeCheck(index,"remove index",size-1);
        T r = listArr[index];
        for(int i=index;i<size;i++)
            listArr[i]=listArr[i+1];
        size--;
        return r;
    }

    @Override
    public int indexOf(Object o) {
        for(int i=0;i<size;i++)
            if(listArr[i]==o)
                return i;
        return -1;
    }

    @Override
    public int lastIndexOf(Object o) {
        return 0;
    }

    @Override
    public ListIterator<T> listIterator() {
        return null;
    }

    @Override
    public ListIterator<T> listIterator(int index) {
        return null;
    }

    @Override
    public List<T> subList(int fromIndex, int toIndex) {
        return null;
    }
}