总结：Java的Stack严格意义来说并不能说是Stack，因为它通过直接继承Vector类，继承了Vector所有的公有方法，它是一个拥有所有Vector容器方法的栈！
该批注的作用是给编译器一条指令，告诉它对被批注的代码元素内部的某些警告保持静默。
| all | 抑制所有警告 |
|---|---|
| boxing | 抑制装箱、拆箱操作时候的警告 |
| cast | 抑制映射相关的警告 |
| dep-ann | 抑制启用注释的警告 |
| deprecation | 抑制过期方法警告 |
| fallthrough | 抑制确在switch中缺失breaks的警告 |
| finally | 抑制finally模块没有返回的警告 |
| hiding | to suppress warnings relative to locals that hide variable |
| incomplete-switch | 忽略没有完整的switch语句的警告 |
| nls | 忽略非nls格式的字符的警告 |
| null | 忽略对null的操作的警告 |
| rawtypes | 使用generics时忽略没有指定相应的类型的警告 |
| restriction | restriction to suppress warnings relative to usage of discouraged or forbidden references |
| serial | 忽略在serializable类中没有声明serialVersionUID变量的警告 |
| static-access | 抑制不正确的静态访问方式警告 |
| synthetic-access | 抑制子类没有按最优方法访问内部类的警告 |
| unchecked | 抑制没有进行类型检查操作的警告 |
| unqualified-field-access | 抑制没有权限访问的域的警告 |
| unused | 抑制没被使用过的代码的警告 |
Spliterator是Java 8中加入的一个新接口；这个名字代表“可拆分迭代器”（splitable iterator）。和Iterator一样，Spliterator也用于遍历数据源中的元素，但它是为了并行执行而设计的。Java 8已经为集合框架中包含的所有数据结构提供了一个默认的Spliterator实现。
fail-fast 机制，即快速失败机制，是java集合(Collection)中的一种错误检测机制。当在迭代集合的过程中该集合在结构上发生改变的时候，就有可能会发生fail-fast，即抛出 ConcurrentModificationException异常。fail-fast机制并不保证在不同步的修改下一定会抛出异常，它只是尽最大努力去抛出，所以这种机制一般仅用于检测bug。
在Vector中依赖modCount实现，一旦modCount发生变化，那么就触发异常。
Java 提供了一种对象序列化的机制，该机制中，一个对象可以被表示为一个字节序列，该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中数据的类型。
将序列化对象写入文件之后，可以从文件中读取出来，并且对它进行反序列化，也就是说，对象的类型信息、对象的数据，还有对象中的数据类型可以用来在内存中新建对象。
函数式编程接口
@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); }; }}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; }}因为和Vector一样都是实现了抽象类AbstractList
所以本质上是一样的，不同的是，Vector的实现因为考虑了多线程的因素，源码应该会比ArrayList更高级。相应的，因为Vector考虑了多线程所以也会降低方法执行的速度和效率。
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;}原文出处:Array源码刨析
群主管理都是支付大佬
