Array源码刨析

目录

• @SuppressWarnings
• Spliterator
• Fail-Fast
• 序列化
• Consumer
• Vector刨析
• ArrayList刨析
• Stack刨析

总结：Java的Stack严格意义来说并不能说是Stack，因为它通过直接继承Vector类，继承了Vector所有的公有方法，它是一个拥有所有Vector容器方法的栈！

@SuppressWarnings

该批注的作用是给编译器一条指令，告诉它对被批注的代码元素内部的某些警告保持静默。

Spliterator

Spliterator是Java 8中加入的一个新接口；这个名字代表“可拆分迭代器”（splitable iterator）。和Iterator一样，Spliterator也用于遍历数据源中的元素，但它是为了并行执行而设计的。Java 8已经为集合框架中包含的所有数据结构提供了一个默认的Spliterator实现。

Fail-Fast

fail-fast 机制，即快速失败机制，是java集合(Collection)中的一种错误检测机制。当在迭代集合的过程中该集合在结构上发生改变的时候，就有可能会发生fail-fast，即抛出 ConcurrentModificationException异常。fail-fast机制并不保证在不同步的修改下一定会抛出异常，它只是尽最大努力去抛出，所以这种机制一般仅用于检测bug。

在Vector中依赖modCount实现，一旦modCount发生变化，那么就触发异常。

序列化

Java 提供了一种对象序列化的机制，该机制中，一个对象可以被表示为一个字节序列，该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中数据的类型。

将序列化对象写入文件之后，可以从文件中读取出来，并且对它进行反序列化，也就是说，对象的类型信息、对象的数据，还有对象中的数据类型可以用来在内存中新建对象。

Consumer

函数式编程接口

@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);

    /**
     * Returns a composed {@code Consumer} that performs, in sequence, this
     * operation followed by the {@code after} operation. If performing either
     * operation throws an exception, it is relayed to the caller of the
     * composed operation.  If performing this operation throws an exception,
     * the {@code after} operation will not be performed.
     *
     * @param after the operation to perform after this operation
     * @return a composed {@code Consumer} that performs in sequence this
     * operation followed by the {@code after} operation
     * @throws NullPointerException if {@code after} is null
     */
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

Vector刨析

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    
    //一个确保足够大的数组缓冲区
    @SuppressWarnings(\"serial\") // Conditionally serializable
    protected Object[] elementData;

    //记录数组缓冲区中实际存入的元素数量
    protected int elementCount;

    //vector容器建议自增的大小
    protected int capacityIncrement;

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    @java.io.Serial
    private static final long serialVersionUID = -2767605614048989439L;

    public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException(\"Illegal Capacity: \"+
                                               initialCapacity);
        //首次Vector初始化
        this.elementData = new Object[initialCapacity];
        //设置下次Vector容量的增加数量
        this.capacityIncrement = capacityIncrement;
    }

    public Vector(int initialCapacity) {
        //若capacityIncrement为空，则默认设置为0，即不会扩大容量
        this(initialCapacity, 0);
    }

    public Vector() {
        //默认Vector仅能存储十个元素,且不会容量不会扩大!
        this(10);
    }

    //Collection对象赋值给Vector的两种情况
    public Vector(Collection<? extends E> c) {
        Object[] a = c.toArray();
        elementCount = a.length;
        //如果c的类对象是ArrayList的话，那么就可以直接赋值
        if (c.getClass() == ArrayList.class) {
            elementData = a;
        } else {
        //elementDate赋值为Object[]
            elementData = Arrays.copyOf(a, elementCount, Object[].class);
        }
    }

    /*
    	arraycopy(src, srcPos, dest, destPos, length)
    	1. src: 源数组
    	2. srcPos: 源数组的起点下标
    	3. dest: 目标数组
    	4. destPos: 目标数组的起点下标
    	5. length: 复制源数组的元素个数
    */
    //拷贝vector
    public synchronized void copyInto(Object[] anArray) {
        System.arraycopy(elementData, 0, anArray, 0, elementCount);
    }

   	//修剪vector
    public synchronized void trimToSize() {
        modCount++;
        int oldCapacity = elementData.length;
        //如果数组的大小大于数组中元素的个数，则将数组容量缩小为元素个数的容量
        if (elementCount < oldCapacity) {
            elementData = Arrays.copyOf(elementData, elementCount);
        }
    }

    /**
     * modCount定义在AbstractList中，用于记录当前集合尝试改变容量的次数
     * 设定容器的最小容量
     */
    public synchronized void ensureCapacity(int minCapacity) {
        if (minCapacity > 0) {
            modCount++;
            if (minCapacity > elementData.length)
                grow(minCapacity);
        }
    }

    /**
     * ArraysSupport.newLength(oldLength, minGrowth, prefGrowth)
     * newLength函数中定义了取oldLength + max(minGrowth, prefGrowth)
     * 即grow函数最小也会增长minGrowth, 最大则增加prefGrowth
     * 也就是说一旦调用了grow()函数，那么增加的容量并不是设定的minCapacity而是经过的	   * 计算的容量
     */
    private Object[] grow(int minCapacity) {
        int oldCapacity = elementData.length;
        int newCapacity = ArraysSupport.newLength(oldCapacity,
                minCapacity - oldCapacity, //minGrow
                capacityIncrement > 0 ? capacityIncrement : oldCapacity//preGrow
                 );
        return elementData = Arrays.copyOf(elementData, newCapacity);
    }

    //默认自增1
    private Object[] grow() {
        return grow(elementCount + 1);
    }

    //设置vector大小
    //第一种情况，若vector的元素数量小于newSize那么直接扩大容量
    //第二种情况，若vector的元素数量大于newSize那么就将多余的部分置为null，但是不修	 //改vector本身的容量
    public synchronized void setSize(int newSize) {
        modCount++;
        if (newSize > elementData.length)
            grow(newSize);
        final Object[] es = elementData;
        for (int to = elementCount, i = newSize; i < to; i++)
            es[i] = null;
        elementCount = newSize;
    }

    //定义容量=容器大小
    public synchronized int capacity() {
        return elementData.length;
    }

    //定义大小=元素数量
    public synchronized int size() {
        return elementCount;
    }

    //判空
    public synchronized boolean isEmpty() {
        return elementCount == 0;
    }

    //获取枚举对象
    public Enumeration<E> elements() {
        return new Enumeration<E>() {
            //自定义枚举接口
            int count = 0;

            //提供给外部循环使用的
            public boolean hasMoreElements() {
                return count < elementCount;
            }
			
            //拿到当前元素的值，并将枚举指向下一个
            public E nextElement() {
                synchronized (Vector.this) {
                    if (count < elementCount) {
                        return elementData(count++);
                    }
                }
                throw new NoSuchElementException(\"Vector Enumeration\");
            }
        };
    }

    //indexOf(Object, x)找到Object则返回下标，反之，返回-1
    public boolean contains(Object o) {
        return indexOf(o, 0) >= 0;
    }

    //从零开始找目标Object
    public int indexOf(Object o) {
        return indexOf(o, 0);
    }

    //应该很好理解，为什么需要将NULL对象和Object对象区分？为什么需要使用equals()?
    //equals()中的对象不能为null, ==判别的是地址是否相同而非大小
    public synchronized int indexOf(Object o, int index) {
        if (o == null) {
            for (int i = index ; i < elementCount ; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = index ; i < elementCount ; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

   //Object最后一次出现的下标
    public synchronized int lastIndexOf(Object o) {
        return lastIndexOf(o, elementCount-1);
    }

    
    public synchronized int lastIndexOf(Object o, int index) {
        if (index >= elementCount)
            throw new IndexOutOfBoundsException(index + \" >= \"+ elementCount);

        if (o == null) {
            for (int i = index; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = index; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

    //获取下标元素
    public synchronized E elementAt(int index) {
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + \" >= \" + elementCount);
        }

        return elementData(index);
    }

    //获取首位元素
    public synchronized E firstElement() {
        if (elementCount == 0) {
            throw new NoSuchElementException();
        }
        return elementData(0);
    }

    //获取最后一位元素
    public synchronized E lastElement() {
        if (elementCount == 0) {
            throw new NoSuchElementException();
        }
        return elementData(elementCount - 1);
    }

    //为特定下标设置元素
    public synchronized void setElementAt(E obj, int index) {
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + \" >= \" +
                                                     elementCount);
        }
        elementData[index] = obj;
    }

    //移除特定下标的元素
    public synchronized void removeElementAt(int index) {
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + \" >= \" +
                                                     elementCount);
        }
        else if (index < 0) {
            throw new ArrayIndexOutOfBoundsException(index);
        }
        int j = elementCount - index - 1;
        //拷贝elementData的index+1处往后的元素至elementData的index处往后的元素
        if (j > 0) {
            System.arraycopy(elementData, index + 1, elementData, index, j);
        }
        modCount++;
        elementCount--;
        elementData[elementCount] = null; /* 为了让GC回收null元素 */
    }

    //在特定下标插入元素
    public synchronized void insertElementAt(E obj, int index) {
        if (index > elementCount) {
            throw new ArrayIndexOutOfBoundsException(index
                                                     + \" > \" + elementCount);
        }
        modCount++;
        final int s = elementCount;
        Object[] elementData = this.elementData;
        //如果容量和元素数量相等，就扩容1
        if (s == elementData.length)
            elementData = grow();
        //拷贝elementData的index往后的元素至elementData的index+1往后的元素
        System.arraycopy(elementData, index,
                         elementData, index + 1,
                         s - index);
        elementData[index] = obj;
        elementCount = s + 1;
    }

    //在vector尾部增加元素
    public synchronized void addElement(E obj) {
        modCount++;
        add(obj, elementData, elementCount);
    }

    //删除特定的元素->先找下标位置->删除特定下标的元素
    public synchronized boolean removeElement(Object obj) {
        modCount++;
        int i = indexOf(obj);
        if (i >= 0) {
            removeElementAt(i);
            return true;
        }
        return false;
    }

    //i=elementCount=0 elementCount=0 -> i=0
    //将所有元素置空，但并未修改容量大小
    public synchronized void removeAllElements() {
        final Object[] es = elementData;
        for (int to = elementCount, i = elementCount = 0; i < to; i++)
            es[i] = null;
        modCount++;
    }

    //手把手教你写深拷贝
    public synchronized Object clone() {
        try {
            @SuppressWarnings(\"unchecked\")
            Vector<E> v = (Vector<E>) super.clone();
            v.elementData = Arrays.copyOf(elementData, elementCount);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn\'t happen, since we are Cloneable
            throw new InternalError(e);
        }
    }

    //也算是深拷贝吧?
    public synchronized Object[] toArray() {
        return Arrays.copyOf(elementData, elementCount);
    }

    //转换成T[]实际上也是
    @SuppressWarnings(\"unchecked\")
    public synchronized <T> T[] toArray(T[] a) {
        //这里会出问题，因为传入的数组太小而无法接收，因此JDK被迫返回了一个新的数组
        //那么传进来的a的所有数据就会为空！
        if (a.length < elementCount)
            return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());

        System.arraycopy(elementData, 0, a, 0, elementCount);

        //意义是什么？应该和JVM的GC回收有关系。
        if (a.length > elementCount)
            a[elementCount] = null;

        return a;
    }

    @SuppressWarnings(\"unchecked\")
    E elementData(int index) {
        return (E) elementData[index];
    }

    @SuppressWarnings(\"unchecked\")
    static <E> E elementAt(Object[] es, int index) {
        return (E) es[index];
    }

    public synchronized E get(int index) {
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);

        return elementData(index);
    }

    //返回值是原来的数据
    public synchronized E set(int index, E element) {
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

    //最尾增加元素，容量不够就扩1
    private void add(E e, Object[] elementData, int s) {
        if (s == elementData.length)
            elementData = grow();
        elementData[s] = e;
        elementCount = s + 1;
    }

    //丢，你没有返回false的情况设个boolean？难蚌
    public synchronized boolean add(E e) {
        modCount++;
        add(e, elementData, elementCount);
        return true;
    }

    //就换个名字?
    public boolean remove(Object o) {
        return removeElement(o);
    }

   //就参数调转一下...
    public void add(int index, E element) {
        insertElementAt(element, index);
    }

    //换了名字又重写了一遍...和removeElementAt相比加了个返回值，返回值是原来的元素
    public synchronized E remove(int index) {
        modCount++;
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        E oldValue = elementData(index);

        int numMoved = elementCount - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--elementCount] = null; // Let gc do its work

        return oldValue;
    }

    //换了个名字
    public void clear() {
        removeAllElements();
    }

    //是否包含集合c的所有元素
    public synchronized boolean containsAll(Collection<?> c) {
        return super.containsAll(c);
    }

    //在vector最后增加c的所有元素
    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        modCount++;
        int numNew = a.length;
        if (numNew == 0)
            return false;
        synchronized (this) {
            Object[] elementData = this.elementData;
            final int s = elementCount;
            //确保又足够的容量
            if (numNew > elementData.length - s)
                elementData = grow(s + numNew);
            //将a从0开始的所有元素拷贝到..., 长度是numNew
            System.arraycopy(a, 0, elementData, s, numNew);
            elementCount = s + numNew;
            return true;
        }
    }

    //先看下面的bulkRemove()
    public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return bulkRemove(e -> c.contains(e));
    }

    //下面
    public boolean retainAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return bulkRemove(e -> !c.contains(e));
    }

    //下面
    @Override
    public boolean removeIf(Predicate<? super E> filter) {
        Objects.requireNonNull(filter);
        return bulkRemove(filter);
    }

    // A tiny bit set implementation

    private static long[] nBits(int n) {
        return new long[((n - 1) >> 6) + 1];
    }
    private static void setBit(long[] bits, int i) {
        bits[i >> 6] |= 1L << i;
    }
    private static boolean isClear(long[] bits, int i) {
        return (bits[i >> 6] & (1L << i)) == 0;
    }

    //不会
    private synchronized boolean bulkRemove(Predicate<? super E> filter) {
        int expectedModCount = modCount;
        final Object[] es = elementData;
        final int end = elementCount;
        int i;
        // Optimize for initial run of survivors
        for (i = 0; i < end && !filter.test(elementAt(es, i)); i++)
            ;
        // Tolerate predicates that reentrantly access the collection for
        // read (but writers still get CME), so traverse once to find
        // elements to delete, a second pass to physically expunge.
        if (i < end) {
            final int beg = i;
            final long[] deathRow = nBits(end - beg);
            deathRow[0] = 1L;   // set bit 0
            for (i = beg + 1; i < end; i++)
                if (filter.test(elementAt(es, i)))
                    setBit(deathRow, i - beg);
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            modCount++;
            int w = beg;
            for (i = beg; i < end; i++)
                if (isClear(deathRow, i - beg))
                    es[w++] = es[i];
            for (i = elementCount = w; i < end; i++)
                es[i] = null;
            return true;
        } else {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            return false;
        }
    }

    //在特定下标处插入所有集合中的元素
    public synchronized boolean addAll(int index, Collection<? extends E> c) {
        if (index < 0 || index > elementCount)
            throw new ArrayIndexOutOfBoundsException(index);

        Object[] a = c.toArray();
        modCount++;
        int numNew = a.length;
        if (numNew == 0)
            return false;
        Object[] elementData = this.elementData;
        final int s = elementCount;
        if (numNew > elementData.length - s)
            elementData = grow(s + numNew);

        int numMoved = s - index;//计算原数组中index后剩余元素的数量
        if (numMoved > 0)
            System.arraycopy(elementData, index,
                             elementData, index + numNew,
                             numMoved);//转移index后的元素
        System.arraycopy(a, 0, elementData, index, numNew);//将c赋入elementData
        elementCount = s + numNew;
        return true;
    }

    public synchronized boolean equals(Object o) {
        return super.equals(o);
    }

    public synchronized int hashCode() {
        return super.hashCode();
    }

    public synchronized String toString() {
        return super.toString();
    }

    //切割数组，其中源码中List分为是否实现了RandomAccess(随机读取)接口两种
    //vector是实现了随机读取接口的容器，拥有更高的读写效率
    //JDK建议实现了随机读取的类使用fori遍历而非iterator
    public synchronized List<E> subList(int fromIndex, int toIndex) {
        return Collections.synchronizedList(super.subList(fromIndex, toIndex),
                                            this);
    }

    //移除范围中的元素,fromIndex是起始下标，toIndex末尾下标
    protected synchronized void removeRange(int fromIndex, int toIndex) {
        modCount++;
        shiftTailOverGap(elementData, fromIndex, toIndex);
    }

    //lo是fromIndex, hi是toIndex
    private void shiftTailOverGap(Object[] es, int lo, int hi) {
        //将es toIndex后所有的元素拷贝到fromIndex后所有的元素的位置上
        System.arraycopy(es, hi, es, lo, elementCount - hi);
        //将elementCount-(toIndex-fromIndex)后的所有元素置空
        for (int to = elementCount, i = (elementCount -= hi - lo); i < to; i++)
            es[i] = null;
    }

    //序列化接口
    @java.io.Serial
    private void readObject(ObjectInputStream in)
            throws IOException, ClassNotFoundException {
        ObjectInputStream.GetField gfields = in.readFields();
        int count = gfields.get(\"elementCount\", 0);
        Object[] data = (Object[])gfields.get(\"elementData\", null);
        if (data == null && !gfields.defaulted(\"elementData\") && count > 0) {
            // If elementData is null due to 8276665 throwing this exception will not
            // overwrite the original ClassNotFoundException exception.
            // That exception has been recorded and will be thrown from OIS.readObject.
            throw new ClassNotFoundException(\"elementData is null\");
        }
        if (count < 0 || data == null || count > data.length) {
            throw new StreamCorruptedException(\"Inconsistent vector internals\");
        }
        elementCount = count;
        elementData = data.clone();
    }

    //序列化接口
    @java.io.Serial
    private void writeObject(java.io.ObjectOutputStream s)
            throws java.io.IOException {
        final java.io.ObjectOutputStream.PutField fields = s.putFields();
        final Object[] data;
        synchronized (this) {
            fields.put(\"capacityIncrement\", capacityIncrement);
            fields.put(\"elementCount\", elementCount);
            data = elementData.clone();
        }
        fields.put(\"elementData\", data);
        s.writeFields();
    }


    public synchronized ListIterator<E> listIterator(int index) {
        if (index < 0 || index > elementCount)
            throw new IndexOutOfBoundsException(\"Index: \"+index);
        return new ListItr(index);
    }

    
    public synchronized ListIterator<E> listIterator() {
        return new ListItr(0);//一个继承Itr并实现了ListIterator的内部类
    }

    public synchronized Iterator<E> iterator() {
        return new Itr();//一个实现了iterator接口的内部类
    }

    private class Itr implements Iterator<E> {
        int cursor;       // 记录着下一个元素的索引，起点是0，终点是elementCount
        int lastRet = -1; // 记录着当前元素的索引，lastRet=cursor-1
        int expectedModCount = modCount;//快速失败机制

        public boolean hasNext() {
            return cursor != elementCount;
        }

        //没啥好看的
        public E next() {
            synchronized (Vector.this) {
                checkForComodification();
                int i = cursor;
                if (i >= elementCount)
                    throw new NoSuchElementException();
                cursor = i + 1;
                return elementData(lastRet = i);
            }
        }

        //当前的元素被移除，那么lastRet就要指向-1，而cursor就要指向当前元素（因为			  remove()函数是使用arraycopy()实现的）
        public void remove() {
            if (lastRet == -1)
                throw new IllegalStateException();
            synchronized (Vector.this) {
                checkForComodification();
                Vector.this.remove(lastRet);//这里增加了modCount
                expectedModCount = modCount;
            }
            cursor = lastRet;
            lastRet = -1;
        }

        //函数式编程接口Consumer(lambda表达式和方法引用等等)
        @Override
        public void forEachRemaining(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            synchronized (Vector.this) {
                final int size = elementCount;
                int i = cursor;
                if (i >= size) {
                    return;
                }
                final Object[] es = elementData;
                if (i >= es.length)
                    throw new ConcurrentModificationException();
                while (i < size && modCount == expectedModCount)
                    action.accept(elementAt(es, i++));//这个将参数传入你写的lambda														表达式或者方法引用
                // modCount==expectedModCount实现了快速失败
                cursor = i;
                lastRet = i - 1;
                checkForComodification();
            }
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

    //和上一个区别不大，也就调了些函数
    final class ListItr extends Itr implements ListIterator<E> {
        ListItr(int index) {
            super();
            cursor = index;
        }

        public boolean hasPrevious() {
            return cursor != 0;
        }

        public int nextIndex() {
            return cursor;
        }

        public int previousIndex() {
            return cursor - 1;
        }

        public E previous() {
            synchronized (Vector.this) {
                checkForComodification();
                int i = cursor - 1;
                if (i < 0)
                    throw new NoSuchElementException();
                cursor = i;
                return elementData(lastRet = i);
            }
        }

        public void set(E e) {
            if (lastRet == -1)
                throw new IllegalStateException();
            synchronized (Vector.this) {
                checkForComodification();
                Vector.this.set(lastRet, e);
            }
        }

        public void add(E e) {
            int i = cursor;
            synchronized (Vector.this) {
                checkForComodification();
                Vector.this.add(i, e);
                expectedModCount = modCount;
            }
            cursor = i + 1;
            lastRet = -1;
        }
    }

    /**
     * @throws NullPointerException {@inheritDoc}
     */
    @Override
    public synchronized void forEach(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        final int expectedModCount = modCount;
        final Object[] es = elementData;
        final int size = elementCount;
        for (int i = 0; modCount == expectedModCount && i < size; i++)
            action.accept(elementAt(es, i));
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }

    /**
     * @throws NullPointerException {@inheritDoc}
     */
    @Override
    public synchronized void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final int expectedModCount = modCount;
        final Object[] es = elementData;
        final int size = elementCount;
        for (int i = 0; modCount == expectedModCount && i < size; i++)
            es[i] = operator.apply(elementAt(es, i));
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        // TODO(8203662): remove increment of modCount from ...
        modCount++;
    }

    @SuppressWarnings(\"unchecked\")
    @Override
    public synchronized void sort(Comparator<? super E> c) {
        final int expectedModCount = modCount;
        Arrays.sort((E[]) elementData, 0, elementCount, c);
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        modCount++;
    }

    /**
     * Creates a <em><a href=\"Spliterator.html#binding\">late-binding</a></em>
     * and <em>fail-fast</em> {@link Spliterator} over the elements in this
     * list.
     *
     * <p>The {@code Spliterator} reports {@link Spliterator#SIZED},
     * {@link Spliterator#SUBSIZED}, and {@link Spliterator#ORDERED}.
     * Overriding implementations should document the reporting of additional
     * characteristic values.
     *
     * @return a {@code Spliterator} over the elements in this list
     * @since 1.8
     */
    @Override
    public Spliterator<E> spliterator() {
        return new VectorSpliterator(null, 0, -1, 0);
    }

    //行百里者半九十，我已经开摆了。
    /** Similar to ArrayList Spliterator */
    final class VectorSpliterator implements Spliterator<E> {
        private Object[] array;
        private int index; // current index, modified on advance/split
        private int fence; // -1 until used; then one past last index
        private int expectedModCount; // initialized when fence set

        /** Creates new spliterator covering the given range. */
        VectorSpliterator(Object[] array, int origin, int fence,
                          int expectedModCount) {
            this.array = array;
            this.index = origin;
            this.fence = fence;
            this.expectedModCount = expectedModCount;
        }

        private int getFence() { // initialize on first use
            int hi;
            if ((hi = fence) < 0) {
                synchronized (Vector.this) {
                    array = elementData;
                    expectedModCount = modCount;
                    hi = fence = elementCount;
                }
            }
            return hi;
        }

        public Spliterator<E> trySplit() {
            int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
            return (lo >= mid) ? null :
                new VectorSpliterator(array, lo, index = mid, expectedModCount);
        }

        @SuppressWarnings(\"unchecked\")
        public boolean tryAdvance(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            int i;
            if (getFence() > (i = index)) {
                index = i + 1;
                action.accept((E)array[i]);
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
                return true;
            }
            return false;
        }

        @SuppressWarnings(\"unchecked\")
        public void forEachRemaining(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            final int hi = getFence();
            final Object[] a = array;
            int i;
            for (i = index, index = hi; i < hi; i++)
                action.accept((E) a[i]);
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }

        public long estimateSize() {
            return getFence() - index;
        }

        public int characteristics() {
            return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
        }
    }

    void checkInvariants() {
        // assert elementCount >= 0;
        // assert elementCount == elementData.length || elementData[elementCount] == null;
    }
}

ArrayList刨析

因为和Vector一样都是实现了抽象类AbstractList所以本质上是一样的，不同的是，Vector的实现因为考虑了多线程的因素，源码应该会比ArrayList更高级。相应的，因为Vector考虑了多线程所以也会降低方法执行的速度和效率。

Stack刨析

public class Stack<E> extends Vector<E> {
    
    public Stack() {
    }

    //在Vector数组尾部压入数据
    public E push(E item) {
        addElement(item);

        return item;
    }

    //返回并移除数据尾部元素
    public synchronized E pop() {
        E       obj;
        int     len = size();

        obj = peek();
        removeElementAt(len - 1);

        return obj;
    }

    //返回数组尾部元素
    public synchronized E peek() {
        int     len = size();

        if (len == 0)
            throw new EmptyStackException();
        return elementAt(len - 1);
    }

    //判空
    public boolean empty() {
        return size() == 0;
    }

    //从尾部开始找到最找出现o的下标
    public synchronized int search(Object o) {
        int i = lastIndexOf(o);

        if (i >= 0) {
            return size() - i;
        }
        return -1;
    }

   //序列化
    @java.io.Serial
    private static final long serialVersionUID = 1224463164541339165L;
}

来源：https://www.cnblogs.com/angelMask/p/16470020.html
本站部分图文来源于网络，如有侵权请联系删除。