AbstractList源码阅读

Posted 2022-03-19 jeremychan

前言

AbstractList是实现List接口的抽象类，AbstractList抽象类与List接口的关系类似于AbstractCollection抽象类与Collection接口的关系。AbstractList与AbstractCollection一样，也是通过提供一些方法的默认实现，简化我们编写List接口的列表类所需付出的努力。

实现列表类的需要记住：

1）要想实现一个不可修改的集合，只需要继承这个类，并且实现get(int)、size()方法；

2）要想实现一个可以修改的集合，还必须重写set(int, E)方法，该方法默认抛出一个异常。如果集合是可动态调整大小的，还必须重写add(int, E)，remove(int)方法

 

一、类定义

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>

除了实现List接口，AbstractList还继承了AbstractCollection抽象类。

 

二、方法定义

（一）构造方法

    protected AbstractList() 
    

提供一个空构造方法，给子类的构造方法调用（通常是隐式调用）

（二）元素的增删改查

（1）

    public boolean add(E e) 
        add(size(), e);
        return true;
    

添加指定元素到列表末端。此方法有可能抛出IndexOutOfBoundsException异常。

方法内部是通过调用add(int, E)方法实现的。

（2）

    public void add(int index, E element) 
        throw new UnsupportedOperationException();
    

添加指定元素到列表的指定位置处。

方法内部默认抛出UnsupportedOperationException。正如前言所讲，如果我们要实现一个不可修改的列表类，则当调用添加方法时，则抛出不支持添加操作的异常；如果我们要实现一个可以修改的列表类，则必须重写此方法。重写此方法之后，此方法在调用过程中有可能抛出ClassCastException、NullPointerException、IllegalArgumentException、IndexOutOfBoundsException等异常。

（3）

    public E remove(int index) 
        throw new UnsupportedOperationException();
    

删除列表中指定位置的元素。

方法内部默认抛出UnsupportedOperationException。原因同上。

（4）

    public E set(int index, E element) 
        throw new UnsupportedOperationException();
    

用指定元素更新列表中指定位置处的元素

方法内部默认抛出UnsupportedOperationException。同上面一样，如果我们要实现一个不可修改的列表类，那么无需实现此方法；反之，要重写此方法。重写此方法之后，此方法还可能抛出ClassCastException、NullPointerException、IllegalArgumentException、IndexOutOfBoundsException等异常。

（5）

abstract public E get(int index);

查找列表指定位置处的元素。此方法有可能抛出IndexOutOfBoundsException异常。

（6）

    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;
    

查找指定元素在列表中第一次出现的索引。

通过列表迭代器的迭代实现。

（7）

    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;
    

查找指定元素在列表中最后一次出现的索引。

通过列表迭代器迭代实现。

（三）批量操作

（1）

    public boolean addAll(int index, Collection<? extends E> c) 
        rangeCheckForAdd(index);
        boolean modified = false;
        for (E e : c) 
            add(index++, e);
            modified = true;
        
        return modified;
    

添加指定集合的所有元素到列表中。

首先通过rangeCheckForAdd()方法判断插入位置是否合法，合法则添加元素；否则抛出异常。

    private void rangeCheckForAdd(int index) 
        if (index < 0 || index > size())
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    

当index超出范围，rangeCheckForAdd()方法抛出IndexOutOfBoundsException异常。

    private String outOfBoundsMsg(int index) 
        return "Index: "+index+", Size: "+size();
    

抛出异常时，使用outOfBoundsMsg()方法提示异常具体信息。

（2）

    public void clear() 
        removeRange(0, size());
    

清空列表，即，删除列表所有元素

内部是通过removeRange()方法实现的

    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();
        
    

（四）相等与哈希

（1）

    public boolean equals(Object o) 
        if (o == this)
            return true;
        if (!(o instanceof List))
            return 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());
    

判断列表与指定对象是否相等，这里判断的是值相等，而不是同一个对象。

判等逻辑如下：

1）如果两个引用指向的对象是同一个对象，那么值肯定相等，返回true；否则，继续判断

2）如果指定对象不是列表，如指定对象是set集合，那么返回false；否则，继续判断

3）获取列表、指定对象的列表迭代器，遍历每个元素，并判断相同位置的元素值是否相等，如果有一个不等，则返回false；否则，说明其中一个迭代器的所有元素在另一个迭代器中出现，且出现的位置相同，如果此时不存在其中一个迭代器剩下元素，那直接返回true

（2）

    public int hashCode() 
        int hashCode = 1;
        for (E e : this)
            hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
        return hashCode;
    

得到列表的哈希码值

方法内部实现是通过遍历列表的每一个元素，得到每个元素的哈希码值（若元素为null，则哈希码值为0；若不为null，则通过hashCode()方法获取元素的哈希码值），然后按照hashCode = 31*hashCode + (e==null ? 0 : e.hashCode()); 的规则计算列表的哈希码值，其中初始hashCode=1。当所有元素遍历完毕，最终的hashCode即为列表的哈希码值，返回即可。

（五）迭代器相关

（1）

    public Iterator<E> iterator() 
        return new Itr();
    

 

（2）

    public ListIterator<E> listIterator() 
        return listIterator(0);
    

 

（3）

    public ListIterator<E> listIterator(final int index) 
        rangeCheckForAdd(index);
        return new ListItr(index);