Jim Blog I've been trying so hard,but doesn't even matter
博客信息

ArrayList源码分析(二)续--方法

发布时间:『 2018-04-20 18:15 』  博客类别:Java核心基础  阅读(73) 评论(0)

紧接上文:http://jimblog.site/blog/articles/89.html

 /**
    *感觉这个有点难理解,我们要考虑两种情况,complement是true还是false
    * 当为true时,如果c中包含elementData[r],将elementData[r]赋给elementData[w++],即覆盖掉不存在的元素 
    * 当为flase时,如果c中不包含elementData[r],将elementData[r]赋给elementData[w++],即覆盖掉存在的元素
    * 下面的 r != size 原注释说防止抛出异常,我也不太清楚怎样才能触发这个异常
    * 再下面的 w != size 时则有元素移除了,把后面的元素赋为null
    */
    private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            for (; r < size; r++)
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            if (r != size) {
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            }
            if (w != size) {
                // clear to let GC do its work
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
        return modified;
    }
    
    /**
     * Save the state of the <tt>ArrayList</tt> instance to a stream (that
     * is, serialize it).
     *
     * @serialData The length of the array backing the <tt>ArrayList</tt>
     *             instance is emitted (int), followed by all of its elements
     *             (each an <tt>Object</tt>) in the proper order.
     * 保存ArrayList状态到输出流,写的东西有size,和数组里的全部元素
     */
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();
        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);
        // Write out all elements in the proper order.
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }
    
    /**
     * Reconstitute the <tt>ArrayList</tt> instance from a stream (that is,
     * deserialize it).
     * 把输出流里的内容赋给a数组
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;
        // Read in size, and any hidden stuff
        s.defaultReadObject();
        // Read in capacity
        s.readInt(); // ignored
        if (size > 0) {
            // be like clone(), allocate array based upon size not capacity
            ensureCapacityInternal(size);
            Object[] a = elementData;
            // Read in all elements in the proper order.
            for (int i=0; i<size; i++) {
                a[i] = s.readObject();
            }
        }
    }
    
    /**
     * Returns a list iterator over the elements in this list (in proper
     * sequence), starting at the specified position in the list.
     * The specified index indicates the first element that would be
     * returned by an initial call to {@link ListIterator#next next}.
     * An initial call to {@link ListIterator#previous previous} would
     * return the element with the specified index minus one.
     *
     * <p>The returned list iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
     *
     * @throws IndexOutOfBoundsException {@inheritDoc}
     * 在不越界的时候,返回一个从index开始的list迭代器
     */
    public ListIterator<E> listIterator(int index) {
        if (index < 0 || index > size)
            throw new IndexOutOfBoundsException("Index: "+index);
        return new ListItr(index);
    }
    
    /**
     * Returns a list iterator over the elements in this list (in proper
     * sequence).
     *
     * <p>The returned list iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
     *
     * @see #listIterator(int)
     * 返回内部类ListItr的迭代器,原注释说这个比AbstractList.ListItr更完善
     * 内部类文章在第三篇
     */
    public ListIterator<E> listIterator() {
        return new ListItr(0);
    }
    
    /**
     * Returns an iterator over the elements in this list in proper sequence.
     *
     * <p>The returned iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
     *
     * @return an iterator over the elements in this list in proper sequence
     * 返回内部类Itr的迭代器,原注释说这个比AbstractList.Itr更完善
     * 内部类文章在第三篇
     */
    public Iterator<E> iterator() {
        return new Itr();
    }
 
   /**
    * 原注解长得没边我去掉了
    * 这个方法返回一个在指定范围的子List,包含fromIndex,不包含toIndex
    * 如果 fromIndex=toIndex ,返回空list
    * 方法用到了内部类SubList,内部类在第三篇文章
    */
   public List<E> subList(int fromIndex, int toIndex) {
        subListRangeCheck(fromIndex, toIndex, size);
        return new SubList(this, 0, fromIndex, toIndex);
    }
    
   /**
    * 判断是否越界
    */
   static void subListRangeCheck(int fromIndex, int toIndex, int size) {
        if (fromIndex < 0)
            throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
        if (toIndex > size)
            throw new IndexOutOfBoundsException("toIndex = " + toIndex);
        if (fromIndex > toIndex)
            throw new IllegalArgumentException("fromIndex(" + fromIndex +
                                               ") > toIndex(" + toIndex + ")");
    }
    
   /**
    * 参数是函数式编程接口 Consumer 
    * 用处就是可以通过Lambda表达式遍历处理元素
    */
    @Override
    public void forEach(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        final int expectedModCount = modCount;
        @SuppressWarnings("unchecked")
        final E[] elementData = (E[]) this.elementData;
        final int size = this.size;
        for (int i=0; modCount == expectedModCount && i < size; i++) {
            action.accept(elementData[i]);
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }
    
   /**
    * 方法名是splitable iterator(可分割迭代器)的简写
    * 用处就是可以并行遍历list元素
    * 具体实现是内部类,<del>完全没有信心分析</del>
    */
   @Override
    public Spliterator<E> spliterator() {
        return new ArrayListSpliterator<>(this, 0, -1, 0);
    }
    
   /**
    * 接收一个函数式编程接口 Predicate 参数
    * 当满足Lambda表达式的条件时移除元素,相当于有一层过滤器
    * 这里需要对BigSet.nextClearBit有点概念,简单说就是没有标记返回本值,被标记了返回下一未标记值
    * 例如第4.5.6个元素是要删除的,会被存到BigSet中,调用方法时如果是BigSet.nextClearBit(0-3)则返回0-3
    * 当BigSet.nextClearBit(4)时,返回7
    * 运行过程大概是:1.把满足删除条件的元素位置放到removeSet,2.判断是否有元素要删除
    * 3.通过nextClearBit方法返回下一不需删除元素位置,例如前面的例子,前面几个元素还是放回原位置
    * 从4开始返回7,则elementData[4]=elementData[7];移除了4,5,6中的元素将依次被7,8,9中的代替
    * 4.把多出的长度置为null
    */
   @Override
    public boolean removeIf(Predicate<? super E> filter) {
        Objects.requireNonNull(filter);
        // figure out which elements are to be removed
        // any exception thrown from the filter predicate at this stage
        // will leave the collection unmodified
        int removeCount = 0;
        final BitSet removeSet = new BitSet(size);
        final int expectedModCount = modCount;
        final int size = this.size;
        for (int i=0; modCount == expectedModCount && i < size; i++) {
            @SuppressWarnings("unchecked")
            final E element = (E) elementData[i];
            if (filter.test(element)) {
                removeSet.set(i);
                removeCount++;
            }
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        // shift surviving elements left over the spaces left by removed elements
        final boolean anyToRemove = removeCount > 0;
        if (anyToRemove) {
            final int newSize = size - removeCount;
            for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) {
                i = removeSet.nextClearBit(i);
                elementData[j] = elementData[i];
            }
            for (int k=newSize; k < size; k++) {
                elementData[k] = null;  // Let gc do its work
            }
            this.size = newSize;
            if (modCount != expectedModCount) {
                throw new ConcurrentModificationException();
            }
            modCount++;
        }
        return anyToRemove;
    }
    
    /**
    * 接收一个函数式编程接口 UnaryOperator 参数
    * 遍历所有元素,将其替换成Lambda表达式的运行结果
    */
    @Override
    @SuppressWarnings("unchecked")
    public void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final int expectedModCount = modCount;
        final int size = this.size;
        for (int i=0; modCount == expectedModCount && i < size; i++) {
            elementData[i] = operator.apply((E) elementData[i]);
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }
    
    /**
    * 接收一个函数式编程接口 Comparator 参数(也可以用以前的老方法写个内部类)
    * 对list进行排序
    */
    @Override
    @SuppressWarnings("unchecked")
    public void sort(Comparator<? super E> c) {
        final int expectedModCount = modCount;
        Arrays.sort((E[]) elementData, 0, size, c);
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }

方法篇的分析就到这里,还有一篇分析ArrayList的内部类

关键字:   java     arraylist     源码  
博主信息
Jim
(生命,是一场徒劳的坚持)