ArrayList---略解

ArrayList—略解

public class ArrayList<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable

可调整大小的数组的实现List接口。 实现所有的可选列表操作，并允许所有的元素， 包括null。除了实现List接口之外，该类还提供了一些方法来操纵内部使用的存储列表的数组大小。

方法摘要如下：

基础方法

Method	Modifier and Type	Description
size	int	返回此列表中的元素数
capacity	int	返回此列表的长度

增

Method	Modifier and Type	Description
add(T t)	void	将指定元素追加到列表的末尾
add(T t)	void	在此列表的指定位置插入指定的元素
add(List list)	void	将指定集合中的所有元素追加到此列表的末尾
add(int index, List list)	void	在此列表的指定位置开始将指定集合中的所有元素插入到此列表中

删

Method	Modifier and Type	Description
remove(int index)	T	删除该列表中指定位置的元素
remove(int fromIndex, int toIndex)	List	从这个列表中删除所有索引在fromIndex（含）和 toIndex 之间的元素
remove(T t)	boolean	从列表中删除指定元素的第一个出现（如果出现）
remove(List list)	void	从此列表中删除指定集合中包含的所有元素
retain(List list);	void	仅保留此列表中包含指定集合中的元素
clear	void	从列表中删除所有元素

改

Method	Modifier and Type	Description
ensureCapacity(how many)	void	如果需要，增加此ArrayList实例的容量，以确保它阔以至少保存最小容量参数指定的元素数（size）
trimToSize()	void	修改这个ArrayList实力的容量是列表的当前的大小
set(int index, T t)	int	用指定的元素替换此列表中指定位置的元素

查

Method	Modifier and Type	Description
contains(T t)	boolean	如果此列表中包含指定的元素，则返回True
contains(List list)	boolean	如果列表中包含指定的列表元素，则返回True
get(int index)	T	返回此列表中指定位置的元素
indexOf(T t)	int	返回此列表中指定元素第一次出现的索引，如果此列表中不包含该元素，则返回-1
lastIndexOf(T t)	int	返回此列表中指定元素最后一次出现的索引，如果此列表中不包含该元素，则返回-1
isEmpty	boolean	如果此列表不包含元素，则返回true（size==0）
subList(int fromIndex, int toIndex)	List	返回此列表的指定的fromIndex（含）和toIndex之间的独占试图
toArray()	Object[]	以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中的所有元素的数组
sort(Comparator comparator)	void	提供使用的Comparator 对此列表进行比较元素

下面为自己重写ArrayList底层的代码展现：（如有问题，评论中见咯！）

List.java

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

public interface List<T> extends Iterable<T>{
    int size();
    default boolean isEmpty(){
        return size()==0;
    };
    default boolean contains(T t){
        return -1 != indexOf(t);
    };
    default boolean contains(List<T> list){
        Iterator<T> it = list.iterator();
        boolean exists = true;
        while (it.hasNext()){
            T next = it.next();
            if (!contains(next)){
                exists = false;
                break;
            }
        }
        return exists;
    };
    int indexOf(T t);
    int lastIndexOf(T t);
    void add(T t);
    void add(List<T> list);
    void add(int index, T t);
    T set(int index, T t);
    void add(int index, List<T> list);
    T get(int index);
    T remove(int index);
    List<T> remove(int fromIndex, int toIndex);
    default boolean remove(T t){
        return false;
    };
    void remove(List<T> list);
    void retain(List<T> list);
    List<T> subList(int fromIndex, int toIndex);
    void sort(Comparator<T> comparator);
    Object[] toArray();
    default void trimToSize(){
        throw new UnsupportedOperationException("trimToSize!!!");
    };
    void clear();
    int capacity();
}

ArrayList.java

import pakage*.AbstractList;
import pakage*.Arrays;
import pakage*.List;

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

public class ArrayList<T> extends AbstractList<T> implements List<T> {
    private final float INCREASE_FACTOR = 1.2F;
    private final int MAX_SIZE = Integer.MAX_VALUE-8;
    private final Object[] EMPTY = {};
    private Object[] temp = EMPTY;
    private Object[] array;

    public ArrayList(int initialCapacity) {
        if(initialCapacity<0 || initialCapacity>MAX_SIZE){
            throw new RuntimeException("initial capacity overflow");
        }
        array = new Object[initialCapacity];
    }

    public ArrayList() {
        array = EMPTY;
    }

    public ArrayList(List<T> list){
        add(list);
    }

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


//    @Override
//    public boolean contains(List<T> list) {
//        int count = 0;
//        for (T t : list) {
//            count += contains(t) ? 1 : 0;
//        }
//        return count == list.size();
//    }

    private int index(T t,boolean forward){
        if(null != t){
            int begin=0,end=size-1;
            while (begin<=end){
                if(forward ? t.equals(array[begin]) : t.equals(array[end])){
                    return forward ? begin : end;
                }
                if(forward) begin++;
                else end--;
            }
        }
        return -1;
    }

    @Override
    public int indexOf(T t) {
        return index(t,true);
    }

    @Override
    public int lastIndexOf(T t) {
        return index(t,false);
    }

    private void release(){
        for (int i = 0; i < size; i++) {
            array[i] = null;
        }
        array = null;
    }

    private void ensureCapacity(int howMany){
        if(size+howMany>array.length){
            temp = new Object[(int)Math.ceil((size+howMany)*INCREASE_FACTOR)];
            for (int i = 0; i < size ; i++) {
                temp[i] = array[i];
            }
            release();
            array = temp;
            temp = EMPTY;
        }
    }



    @Override
    public void add(T t) {
        requireNonNull(t);
        ensureCapacity(1);
        array[size++] = t;
    }

    @Override
    public void add(List<T> list) {
        requireNotEmpty(list);
        final int N = list.size();
        ensureCapacity(N);
        System.arraycopy(list.toArray(),0,array,size,N);
        size+=N;
    }

    @Override
    public void add(int index, T t) {
        validateIndex(index,true);
        requireNonNull(t);
        ensureCapacity(1);
        if(index!=size){
            System.arraycopy(array,index,array,index+1,size-index);
        }
        array[index] = t;
        size++;
    }

    @Override
    public T set(int index, T t) {
        validateIndex(index,false);
        requireNonNull(t);
        T _t = (T)array[index];
        array[index] = t;
        return _t;
    }

    @Override
    //在指定下标下插入集合
    public void add(int index, List<T> list) {
        requireNotEmpty(list);
        validateIndex(index,true);
        final int N = list.size();
        ensureCapacity(N);
        System.arraycopy(array,index,array,index+N,size-index);
        System.arraycopy(list.toArray(),0,array,index,N);
        size += N;
    }

    @Override
    public T get(int index) {
        validateIndex(index,false);
        return (T)array[index];
    }

    private T _remove(int index){
        T t = (T)array[index];
        System.arraycopy(array,index+1,array,index,size-index-1);
        size--;
        return t;
    }

    @Override
    public T remove(int index) {
        validateIndex(index,false);
        return _remove(index);
    }

    private List<T> _subList(int fromIndex, int toIndex){
        List<T> list = new ArrayList<>(toIndex-fromIndex+1);
        for (int i = fromIndex; i <= toIndex; i++) {
            list.add((T) array[i]);
        }
        return list;
    }

    @Override
    public List<T> remove(int fromIndex, int toIndex) {
        validateIndex(fromIndex, toIndex);
        //即将被删除的元素的数量
        final int N = toIndex-fromIndex+1;
        //被删除元素之后的元素数量
        final int C = size-toIndex-1;
        List<T> rtn = _subList(fromIndex, toIndex);
        System.arraycopy(array,toIndex+1,array,fromIndex,C);

        //清楚重复的元素引用
        for (int i = fromIndex+C; i <size ; i++) {
            array[i] = null;
        }

        size -= N;
        return rtn;
    }

    private boolean _remove(T t){
        //定位t下标
        int index = indexOf(t);
        // -1表示array中不存在对象t
        if(-1 == index){
            return false;
        }
        _remove(index);
        return true;
    }

    @Override
    public boolean remove(T t) {
        requireNonNull(t);
        return _remove(t);
    }

    @Override
    public void remove(List<T> list) {
        requireNotEmpty(list);
        for (T t : list) {
            _remove(t);
        }
    }

    @Override
    public void retain(List<T> list) {
        requireNotEmpty(list);
        temp = new Object[size];
        int count = 0,index;
        for (T t : list) {
            if(-1 != (index=indexOf(t))){
                temp[count++] = array[index];
            }
        }
        release();
        array = temp;
        temp = EMPTY;
        size = count;
    }

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

    @Override
    public void sort(Comparator<T> comparator) {
        if(size<=1) return;
        if(size<=7){
            Arrays.selectSort(array,0,size-1,comparator);
        }else {
            Arrays.quickSort(array,0,size-1,comparator);
        }
    }

    @Override
    public Object[] toArray() {
        Object[] rtn = new Object[size];
        System.arraycopy(array,0,rtn,0,size);
        return rtn;
    }

    @Override
    public void trimToSize() {
        temp = toArray();
        release();
        array = temp;
        temp = EMPTY;
    }

    @Override
    public void clear() {
        release();
        array = EMPTY;
        size = 0;
    }

    @Override
    public int capacity() {
        return array.length;
    }

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

    //内部类
    private class Itr implements Iterator<T>{
        private int i = 0;

        @Override
        public boolean hasNext() {
            return size>0 && i < size;
        }

        @Override
        public T next() {
            return (T)array[i++];
        }
    }
}