Java集合框架剖析(2)——AbstractXXX模板类

╰+攻爆jí腚メ 2022-05-28 05:51 105阅读 0赞

上文[Java集合框架剖析（1）][Java_1]分析了Collection上层的一些接口。

为了方便，Java抽象出AbstractCollection类来让其他类继承，该类实现类Collection中的绝大部分方法。AbstractList和AbstractSet都继承与AbstractCollection，具体的List实现类继承与AbstractList，而Set的实现类则继承与AbstractSet。  
![这里写图片描述][70]

# AbstractCollection #

![这里写图片描述][70 1]

AbstractCollection是一个抽象类，它实现了Collection中除了**iterator()和size()**之外的所有方法。AbstractCollection的主要作用是方便其他类实现Collection.，比如ArrayList、LinkedList等。它们想要实现Collection接口，通过集成AbstractCollection就已经实现大部分方法了，再实现一下**iterator()和size()**即可。AbstractCollection的设计就是一个模板类。

![这里写图片描述][70 2]

Abstract的部分代码如下:  
![这里写图片描述][70 3]  
![这里写图片描述][70 4]  
![这里写图片描述][70 5]  
![这里写图片描述][70 6]  
![这里写图片描述][70 7]  
![这里写图片描述][70 8]  
![这里写图片描述][70 9]  
![这里写图片描述][70 10]  
![这里写图片描述][70 11]

# AbstractList #

![这里写图片描述][70 12]  
AbstractList是一个继承AbstractCollection，并且实现了List接口的抽象类。它实现了List中除了size()、get(int location)之外的方法。  
AbstractList的主要作用：它实现了List接口中的大部分函数，从而方便其它类继承List。另外，和AbstractCollection相比，AbstractList抽象类中，实现了iterator()方法。  
![这里写图片描述][70 13]

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> { 
    
        protected AbstractList() {
        }
    
        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();
        }
    
        public E remove(int index) {
            throw new UnsupportedOperationException();
        }
    
    /***************************** Search Operations**********************************/
        public int indexOf(Object o) { //搜索对象o的索引
            ListIterator<E> it = listIterator();
            if (o==null) {
                while (it.hasNext())
                    if (it.next()==null) //执行it.next()，会先返回it指向位置的值，然后it会移到下一个位置
                        return it.previousIndex(); //所以要返回it.previousIndex(); 关于it几个方法的源码在下面
            } 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;
        }
    /**********************************************************************************/
    
    /****************************** Bulk Operations ***********************************/
        public void clear() {
            removeRange(0, size());
        }
    
        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;
        }
    
        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();
            }
        }
    /**********************************************************************************/
    
    /********************************* Iterators **************************************/
        public Iterator<E> iterator() {
            return new Itr();
        }
    
        public ListIterator<E> listIterator() {
            return listIterator(0); //返回的iterator索引从0开始
        }
    
        public ListIterator<E> listIterator(final int index) {
            rangeCheckForAdd(index); //首先检查index范围是否正确
    
            return new ListItr(index); //ListItr继承与Itr且实现了ListIterator接口，Itr实现了Iterator接口，往下看
        }
    
        private class Itr implements Iterator<E> {       
            int cursor = 0; //元素的索引，当调用next()方法时，返回当前索引的值
            int lastRet = -1; //lastRet也是元素的索引，但如果删掉此元素，该值置为-1
             /* *迭代器都有个modCount值，在使用迭代器的时候，如果使用remove,add等方法的时候都会修改modCount， *在迭代的时候需要保持单线程的唯一操作，如果期间进行了插入或者删除，modCount就会被修改，迭代器就会检测到被并发修改，从而出现运行时异常。 *举个简单的例子，现在某个线程正在遍历一个List，另一个线程对List中的某个值做了删除，那原来的线程用原来的迭代器当然无法正常遍历了 */
            int expectedModCount = modCount;
    
            public boolean hasNext() {
                return cursor != size(); //当索引值和元素个数相同时表示没有下一个元素了，索引是从0到size-1
            }
    
            public E next() {
                checkForComodification(); //检查modCount是否改变
                try {
                    int i = cursor; //next()方法主要做了两件事：
                    E next = get(i); 
                    lastRet = i;
                    cursor = i + 1; //1.将索引指向了下一个位置
                    return next; //2. 返回当前索引的值
                } catch (IndexOutOfBoundsException e) {
                    checkForComodification();
                    throw new NoSuchElementException();
                }
            }
    
            public void remove() {
                if (lastRet < 0) //lastRet<0表示已经不存在了
                    throw new IllegalStateException();
                checkForComodification();
    
                try {
                    AbstractList.this.remove(lastRet);
                    if (lastRet < cursor)
                        cursor--; //原位置的索引值减小了1，但是实际位置没变
                    lastRet = -1; //置为-1表示已删除
                    expectedModCount = modCount;
                } catch (IndexOutOfBoundsException e) {
                    throw new ConcurrentModificationException();
                }
            }
    
            final void checkForComodification() {
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
            }
        }
    
        private class ListItr extends Itr implements ListIterator<E> { 
            ListItr(int index) {
                cursor = index;
            }
    
            public boolean hasPrevious() {
                return cursor != 0;
            }
    
            public E previous() {
                checkForComodification();
                try {
                    int i = cursor - 1; //previous()方法中也做了两件事：
                    E previous = get(i); //1. 将索引向前移动一位
                    lastRet = cursor = i; //2. 返回索引处的值
                    return previous;
                } catch (IndexOutOfBoundsException e) {
                    checkForComodification();
                    throw new NoSuchElementException();
                }
            }
    
            public int nextIndex() { //iterator中的index本来就是下一个位置，在next()方法中可以看出
                return cursor;
            }
    
            public int previousIndex() {
                return cursor-1;
            }
    
            public void set(E e) { //修改当前位置的元素
                if (lastRet < 0)
                    throw new IllegalStateException();
                checkForComodification();
    
                try {
                    AbstractList.this.set(lastRet, e);
                    expectedModCount = modCount;
                } catch (IndexOutOfBoundsException ex) {
                    throw new ConcurrentModificationException();
                }
            }
    
            public void add(E e) { //在当前位置添加元素
                checkForComodification();
    
                try {
                    int i = cursor;
                    AbstractList.this.add(i, e);
                    lastRet = -1;
                    cursor = i + 1;
                    expectedModCount = modCount;
                } catch (IndexOutOfBoundsException ex) {
                    throw new ConcurrentModificationException();
                }
            }
        }
    /**********************************************************************************/
    
        //获得子List，详细源码往下看SubList类
        public List<E> subList(int fromIndex, int toIndex) {
            return (this instanceof RandomAccess ?
                    new RandomAccessSubList<>(this, fromIndex, toIndex) :
                    new SubList<>(this, fromIndex, toIndex));
        }
    
    /*************************** Comparison and hashing *******************************/
        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());
        }
    
        public int hashCode() { //hashcode
            int hashCode = 1;
            for (E e : this)
                hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
            return hashCode;
        }
    /**********************************************************************************/ 
        protected transient int modCount = 0;
    
        private void rangeCheckForAdd(int index) {
            if (index < 0 || index > size())
                throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    
        private String outOfBoundsMsg(int index) {
            return "Index: "+index+", Size: "+size();
        }
    }
    
    class SubList<E> extends AbstractList<E> { 
        private final AbstractList<E> l;
        private final int offset;
        private int size;
        /* 从SubList源码可以看出，当需要获得一个子List时，底层并不是真正的返回一个子List，还是原来的List，只不过 * 在操作的时候，索引全部限定在用户所需要的子List部分而已 */
        SubList(AbstractList<E> list, int fromIndex, int toIndex) {
            if (fromIndex < 0)
                throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
            if (toIndex > list.size())
                throw new IndexOutOfBoundsException("toIndex = " + toIndex);
            if (fromIndex > toIndex)
                throw new IllegalArgumentException("fromIndex(" + fromIndex +
                                                   ") > toIndex(" + toIndex + ")");
            l = list; //原封不动的将原来的list赋给l
            offset = fromIndex; //偏移量，用在操作新的子List中
            size = toIndex - fromIndex; //子List的大小，所以子List中不包括toIndex处的值，即子List中包括左边不包括右边
            this.modCount = l.modCount;
        }
        //注意下面所有的操作都在索引上加上偏移量offset，相当于在原来List的副本上操作子List
        public E set(int index, E element) {
            rangeCheck(index);
            checkForComodification();
            return l.set(index+offset, element);
        }
    
        public E get(int index) {
            rangeCheck(index);
            checkForComodification();
            return l.get(index+offset);
        }
    
        public int size() {
            checkForComodification();
            return size;
        }
    
        public void add(int index, E element) {
            rangeCheckForAdd(index);
            checkForComodification();
            l.add(index+offset, element);
            this.modCount = l.modCount;
            size++;
        }
    
        public E remove(int index) {
            rangeCheck(index);
            checkForComodification();
            E result = l.remove(index+offset);
            this.modCount = l.modCount;
            size--;
            return result;
        }
    
        protected void removeRange(int fromIndex, int toIndex) {
            checkForComodification();
            l.removeRange(fromIndex+offset, toIndex+offset);
            this.modCount = l.modCount;
            size -= (toIndex-fromIndex);
        }
    
        public boolean addAll(Collection<? extends E> c) {
            return addAll(size, c);
        }
    
        public boolean addAll(int index, Collection<? extends E> c) {
            rangeCheckForAdd(index);
            int cSize = c.size();
            if (cSize==0)
                return false;
    
            checkForComodification();
            l.addAll(offset+index, c);
            this.modCount = l.modCount;
            size += cSize;
            return true;
        }
    
        public Iterator<E> iterator() {
            return listIterator();
        }
    
        public ListIterator<E> listIterator(final int index) {
            checkForComodification();
            rangeCheckForAdd(index);
    
            return new ListIterator<E>() {
                private final ListIterator<E> i = l.listIterator(index+offset); //相当子List的索引0
    
                public boolean hasNext() {
                    return nextIndex() < size;
                }
    
                public E next() {
                    if (hasNext())
                        return i.next();
                    else
                        throw new NoSuchElementException();
                }
    
                public boolean hasPrevious() {
                    return previousIndex() >= 0;
                }
    
                public E previous() {
                    if (hasPrevious())
                        return i.previous();
                    else
                        throw new NoSuchElementException();
                }
    
                public int nextIndex() {
                    return i.nextIndex() - offset;
                }
    
                public int previousIndex() {
                    return i.previousIndex() - offset;
                }
    
                public void remove() {
                    i.remove();
                    SubList.this.modCount = l.modCount;
                    size--;
                }
    
                public void set(E e) {
                    i.set(e);
                }
    
                public void add(E e) {
                    i.add(e);
                    SubList.this.modCount = l.modCount;
                    size++;
                }
            };
        }
    
        public List<E> subList(int fromIndex, int toIndex) {
            return new SubList<>(this, fromIndex, toIndex);
        }
    
        private void rangeCheck(int index) {
            if (index < 0 || index >= size)
                throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    
        private void rangeCheckForAdd(int index) {
            if (index < 0 || index > size)
                throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    
        private String outOfBoundsMsg(int index) {
            return "Index: "+index+", Size: "+size;
        }
    
        private void checkForComodification() {
            if (this.modCount != l.modCount)
                throw new ConcurrentModificationException();
        }
    }
    
    class RandomAccessSubList<E> extends SubList<E> implements RandomAccess { 
        RandomAccessSubList(AbstractList<E> list, int fromIndex, int toIndex) {
            super(list, fromIndex, toIndex);
        }
    
        public List<E> subList(int fromIndex, int toIndex) {
            return new RandomAccessSubList<>(this, fromIndex, toIndex);
        }
    }

# AbstractSet #

![这里写图片描述][70 14]  
AbstractSet是一个继承与AbstractCollection，并且实现了Set接口的抽象类。由于Set接口和Collection接口中的API完全一样，所以Set也就没有自己单独的API。和AbstractCollection一样，它实现了List中除iterator()和size()外的方法。所以源码和AbstractCollection的一样。  
![这里写图片描述][70 15]  
AbstractSet的主要作用：它实现了Set接口中的大部分函数，从而方便其他类实现Set接口。

[Java_1]: https://blog.csdn.net/sicofield/article/details/79755924
[70]: /images/20220528/7c38d3095ee74046ac63004aea56e386.png
[70 1]: /images/20220528/08833933d13d417a98830d85c2b859ce.png
[70 2]: /images/20220528/1b912317fec246178e1197f4175a0cc7.png
[70 3]: /images/20220528/46477056fef84908af12dc3a3304e705.png
[70 4]: /images/20220528/3e0bfa545b4f427aa252f77dddbebdc8.png
[70 5]: /images/20220528/0d02dc68d6644760957c101bf9594d52.png
[70 6]: /images/20220528/046f3ab8385b44108dc1bdddae2b83e6.png
[70 7]: /images/20220528/f7c0d10cef014b1bbf1a2339c45b4889.png
[70 8]: /images/20220528/673c140883ed490eb45861b0edc3f60f.png
[70 9]: /images/20220528/ec29ba059d9d476a896b9496d284a311.png
[70 10]: /images/20220528/1b430f568d0941d6852e9e506b7e717a.png
[70 11]: /images/20220528/fcbc982c6ba5467199d9413fea16b5c3.png
[70 12]: /images/20220528/982c028df48d47bf98efc8572d2a0b57.png
[70 13]: /images/20220528/b8abbf1686f84362a85ed49578b03f0b.png
[70 14]: /images/20220528/79ac86fde648494c9ece9be98050ee93.png
[70 15]: /images/20220528/fd3a304f5b5e440e9cae32107295ef38.png