【JavaSE】CopyOnWriteArrayList核心源码阅读

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    
    //创建一个ReentrantLock 锁对象
    final transient ReentrantLock lock = new ReentrantLock();

    
    //创建一个Object类型数组
    private transient volatile Object[] array;

    /**
     * Gets the array.  Non-private so as to also be accessible
     * from CopyOnWriteArraySet class.
     */
    
    //得到当前数组
    final Object[] getArray() {
        return array;
    }

    /**
     * Sets the array.
     */

    //将传进来的数组覆盖当前array数组
    final void setArray(Object[] a) {
        array = a;
    }

    
    //无参构造方法 创建一个空数组 覆盖当前array数组
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }


    //通过一个数组和下标返回下标值
    @SuppressWarnings("unchecked")
    private E get(Object[] a, int index) {
        return (E) a[index];
    }

    //通过下标返回array数组该下标的值
    public E get(int index) {
        return get(getArray(), index);
    }

    
    public E set(int index, E element) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            E oldValue = get(elements, index);

            if (oldValue != element) {
                int len = elements.length;
                Object[] newElements = Arrays.copyOf(elements, len);
                newElements[index] = element;
                setArray(newElements);
            } else {
                // Not quite a no-op; ensures volatile write semantics
                setArray(elements);
            }
            return oldValue;
        } finally {
            lock.unlock();
        }
    }


    //添加一个元素到array数组尾部   
    public boolean add(E e) {
        //上锁
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //将array数组赋给elements数组
            Object[] elements = getArray();
            获取elements数组的长度
            int len = elements.length;
            //创建一个新数组并复制elements数组 并长度加一
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            //将传进来的值赋给下标为len
            newElements[len] = e;
            //将newElements 再覆盖array数组
            setArray(newElements);
            return true;
        } finally {
            //释放锁
            lock.unlock();
        }
    }


    //将element存入index下标下
    public void add(int index, E element) {
        //加锁
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //将array赋给elements
            Object[] elements = getArray();
            //获取elements数组的长度
            int len = elements.length;
            //判断传入下标是否在该数组范围中
            if (index > len || index < 0)
                不在范围 则抛出异常
                throw new IndexOutOfBoundsException("Index: "+index+
                                                    ", Size: "+len);
            Object[] newElements;
            //获取传入下标到数组尾部下标的长度
            int numMoved = len - index;
            //如果长度为0 则直接将array复制给newElements
            if (numMoved == 0)
                newElements = Arrays.copyOf(elements, len + 1);
            else {
                //否则创建一个新的数组 赋给newElements 
                newElements = new Object[len + 1];
                //将elements数组从0到index复制到newElements从下标0开始
                System.arraycopy(elements, 0, newElements, 0, index);
                //将elements数组从index到结束复制到newElements 从index+1开始
                System.arraycopy(elements, index, newElements, index + 1,
                                 numMoved);
            }
            //将element赋给下标index
            newElements[index] = element;
            //将newElements数组赋给array数组
            setArray(newElements);
        } finally {
            //释放锁
            lock.unlock();
        }
    }
    
        
    //删除index下标的元素
    public E remove(int index) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //将array数组赋给elements数组
            Object[] elements = getArray();
            //获取elenments数组长度
            int len = elements.length;
            获取elements index下标的的元素
            E oldValue = get(elements, index);
            获取index后半部分的长度
            int numMoved = len - index - 1;
            //如果numMoved长度为0 直接复制0到len-1 给array数组
            if (numMoved == 0)
                setArray(Arrays.copyOf(elements, len - 1));
            else {
                //否则
                Object[] newElements = new Object[len - 1];
                //复制elements数组 从0 到index 给newElements数组从0开始
                System.arraycopy(elements, 0, newElements, 0, index);
                //复制elements 从index+1 到结束 给newElements数组从index开始
                System.arraycopy(elements, index + 1, newElements, index,
                                 numMoved);
                //将newElements数组赋给aray
                setArray(newElements);
            }
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

   
    //删除一段数据
    void removeRange(int fromIndex, int toIndex) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //创建一个新的数组
            Object[] elements = getArray();
            //得到该数组长度
            int len = elements.length;
            
            //判断传入的下标段是否在该数组中
            if (fromIndex < 0 || toIndex > len || toIndex < fromIndex)
                throw new IndexOutOfBoundsException();
            //计算出删除数据后长度
            int newlen = len - (toIndex - fromIndex);
            //算出下标后到结尾的长度
            int numMoved = len - toIndex;
           //如果刚好要删除的数据到原数组的末尾  
           if (numMoved == 0)
                //直接复制被删除下标段第一个下标前的元素
                setArray(Arrays.copyOf(elements, newlen));
            else {
                //创建一个新的数组
                Object[] newElements = new Object[newlen];
                //复制从下标0到删除段第一个下标的元素并从下标0开始
                System.arraycopy(elements, 0, newElements, 0, fromIndex);
                //接着复制删除段最后一个下标到结尾的元素并从被删除下标段第一个元素下标开始
                System.arraycopy(elements, toIndex, newElements,
                                 fromIndex, numMoved);
                setArray(newElements);
            }
        } finally {
            lock.unlock();
        }
    }

    //通过传入元素名称删除元素
    public boolean removeAll(Collection<?> c) {
        //如果是空的则抛出空指针异常
        if (c == null) throw new NullPointerException();
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //将该数组赋值给一个新数组
            Object[] elements = getArray();
            //获得该数组长度
            int len = elements.length;
            //如果长度不为0
            if (len != 0) {
                // temp array holds those elements we know we want to keep
                int newlen = 0;
                //定义一个新数组
                Object[] temp = new Object[len];
                for (int i = 0; i < len; ++i) {
                    Object element = elements[i];
                    //循环这个数组元素 判断如果元素不等于传进来的元素 
                    //则该元素赋给新数组 新数组下标++
                    if (!c.contains(element))
                        temp[newlen++] = element;
                }
                //判断如果这个 新数组下标不等于 len 说明已经判断到了要删除的元素  
                //后面的元素直接复制即可
                if (newlen != len) {
                    setArray(Arrays.copyOf(temp, newlen));
                    return true;
                }
            }
            return false;
        } finally {
            lock.unlock();
        }
    }


    //清空数据
    public void clear() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //将一个空的数组赋给array数组
            setArray(new Object[0]);
        } finally {
            lock.unlock();
        }
    }

    
    public boolean addAll(Collection<? extends E> c) {
        Object[] cs = (c.getClass() == CopyOnWriteArrayList.class) ?
            ((CopyOnWriteArrayList<?>)c).getArray() : c.toArray();
        if (cs.length == 0)
            return false;
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            if (len == 0 && cs.getClass() == Object[].class)
                setArray(cs);
            else {
                Object[] newElements = Arrays.copyOf(elements, len + cs.length);
                System.arraycopy(cs, 0, newElements, len, cs.length);
                setArray(newElements);
            }
            return true;
        } finally {
            lock.unlock();
        }
    }

    //排序
    public void sort(Comparator<? super E> c) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            Object[] newElements = Arrays.copyOf(elements, elements.length);
            @SuppressWarnings("unchecked") E[] es = (E[])newElements;
            Arrays.sort(es, c);
            setArray(newElements);
        } finally {
            lock.unlock();
        }
    }

    
    //判断两个对象是否相等
    public boolean equals(Object o) {
        //如果地址相等则直接返回true
        if (o == this)
            return true;
        if (!(o instanceof List))
            return false;

        List<?> list = (List<?>)(o);
        Iterator<?> it = list.iterator();
        Object[] elements = getArray();
        int len = elements.length;
        for (int i = 0; i < len; ++i)
            if (!it.hasNext() || !eq(elements[i], it.next()))
                return false;
        if (it.hasNext())
            return false;
        return true;
    }

    
    //获取hashCode
    public int hashCode() {
        int hashCode = 1;
        Object[] elements = getArray();
        int len = elements.length;
        for (int i = 0; i < len; ++i) {
            Object obj = elements[i];
            hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());
        }
        return hashCode;
    }
}

部分注释还未完成 待续......