AbstractList源码解析(JDK1.8)

1. 概述

• 该抽象类继承AbstractCollection<E>，实现List<E>，那么该类支持随机访问数据存储（如数组）。该抽象类衍生了很多子类，包括ArrayList。

2. 构造器

    //唯一的构造器，用于子类构造函数的调用，通常是隐式的
    protected AbstractList() {
    }

3. 方法

    //添加元素到list的最后
    public boolean add(E e) {
        add(size(), e);
        return true;
    }
    //获取指定位置的元素
    abstract public E get(int index);
    //将指定位置设置为指定元素
    public E set(int index, E element) {
        throw new UnsupportedOperationException();
    }
    //向某处插入元素，后面的元素依次往后移
    public void add(int index, E element) {
        throw new UnsupportedOperationException();
    }
    //将集合c中的元素添加到该list列表
    //很多实现都将覆盖此方法
    public boolean addAll(int index, Collection<? extends E> c) {
        //判断传的小标是否合法，即应大于等于0且小于size()
        rangeCheckForAdd(index);
        boolean modified = false;
        for (E e : c) {
            add(index++, e);
            modified = true;
        }
        return modified;
    }


    //移除指定位置的元素
    public E remove(int index) {
        throw new UnsupportedOperationException();
    }
    //此实现首先获取一个列表迭代器。然后，在列表上进行迭代，直到找到指定的元素
    //或到达列表的末尾。
    public int indexOf(Object o) {
        ListIterator<E> it = listIterator();
        if (o==null) {
            while (it.hasNext())
                if (it.next()==null)
                    return it.previousIndex();
        } else {
            while (it.hasNext())
                if (o.equals(it.next()))
                    return it.previousIndex();
        }
        return -1;
    }
    
    public int lastIndexOf(Object o) {
        //获取一个指向列表末尾的列表迭代器
        ListIterator<E> it = listIterator(size());
        //然后向前一直寻找直到找到指定的元素
        if (o==null) {
            while (it.hasPrevious())
                if (it.previous()==null)
                    return it.nextIndex();
        } else {
            while (it.hasPrevious())
                if (o.equals(it.previous()))
                    return it.nextIndex();
        }
        return -1;
    }
    
    //清除列表，将小标从0开始到size()结束
    public void clear() {
        removeRange(0, size());
    }
    //fromIndex到toIndex的元素都移除
    protected void removeRange(int fromIndex, int toIndex) {
        ListIterator<E> it = listIterator(fromIndex);
        for (int i=0, n=toIndex-fromIndex; i<n; i++) {
            it.next();
            it.remove();
        }
    }
    //比较两元素内容是否相等
    public boolean equals(Object o) {
        //内容是否相等
        if (o == this)
            return true;
        //当且仅当元素o是List
        if (!(o instanceof List))
            return false;
        //其中包含的每个元素都要相等，不然返回false
        ListIterator<E> e1 = listIterator();
        ListIterator<?> e2 = ((List<?>) o).listIterator();
        while (e1.hasNext() && e2.hasNext()) {
            E o1 = e1.next();
            Object o2 = e2.next();
            if (!(o1==null ? o2==null : o1.equals(o2)))
                return false;
        }
        return !(e1.hasNext() || e2.hasNext());
    }



	//返回hash值
	public int hashCode() {
        int hashCode = 1;
        for (E e : this)
            hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
        return hashCode;
    }