Array源码刨析

AI助手支持GPT4.0

总结：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

函数式编程接口

@FunctionalInterfacepublic 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;}