手写ArrayList

先创建一个List接口，支持泛型，继承Iterable接口

public interface List <E> extends Iterable<E> {
    public void add(E element);
    public void add(int index,E element);
    public void remove(E element);
    public E remove(int index);
    public E get(int index);
    public E set(int index,E element);
    public int size();
    public int IndexOf(E element);
    public boolean contains(E element);
    public boolean isEmpty();
    public void clear();
    public void sort(Comparator<E> comparator);
    public List<E>sublist(int formindex,int toindex);
}

然后创建一个类实现List接口 ，再实现List里面的方法

public class Arraylistzy<E> implements List<E> {
    private E[]data;
    private int size;
    private static int DEFAULT_CAPACITY=10;

    public Arraylistzy(){
        this(DEFAULT_CAPACITY);
    }

    public Arraylistzy(int Capacity) {
        if (Capacity <= 0)
            {throw new IllegalArgumentException("长度异常");}
           data = (E[]) new Object[Capacity];
            size=0;

    }

    public Arraylistzy(E[] arr){
        if (arr == null) {
            throw new IllegalArgumentException("长度不能为空");
        }
        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("数组异常");
      if (size==data.length)
          resize(data.length*2);
      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("异常");
        E ret=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 ret;
    }
    
    //获取
    @Override
    public E get(int index) {
        if (index<0||index>size)
            throw new IllegalArgumentException("get异常");
        return data[index];
    }
    
    //修改
    @Override
    public E set(int index, E element) {
        if (index<0||index>size)
            throw new IllegalArgumentException("set异常");
        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) {
        if (comparator==null)
            throw new IllegalArgumentException("无数据");
        for (int i = 0; i < size-1; i++) {
            E e=data[i];
            int j;
            for(j=i;j>0&&comparator.compare(data[i],e)>0 ;j--)
                data[j]=data[j-1];
                data[j]=e;
        }
    }
    
    //区间
    @Override
    public List<E> sublist(int formindex, int toindex) {
        if (formindex<0||toindex>=size||formindex>=toindex)
            throw new IllegalArgumentException("set异常");
            Arraylistzy<E> list=new Arraylistzy<>();
        for (int i = formindex; i < toindex; i++) {
            list.add(data[i]);
        }
        return list;
    }
    
    //迭代
    @Override
    public Iterator<E> iterator() {
        return new Arraylistzytertor();
    }
    private class Arraylistzytertor  implements Iterator<E>{
        private int cur=0;
        @Override
        public boolean hasNext() {
            return cur<size;
        }

        @Override
        public E next() {
            return data[cur++];
        }
    }
    
    
    @Override
    public String toString(){
        StringBuffer sb = new StringBuffer();
        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 Arraylistzy){
            Arraylistzy<E> other= (Arraylistzy<E>) obj;
            if (this.size==other.size) {
                for (int i = 0; i < this.size; i++) {
                    if (!this.data[i].equals(other.data[i]))
                        return false;
                }
                return true;
            }else
                return false;
        }else
            return false;
    }

    @Override
    public int hashCode() {
        int result = Arrays.hashCode(data);
        result = 31 * result + size;
        return result;
    }
}