模块  java.base
软件包  java.util

Class Vector<E>

  • 参数类型
    E - 组件元素的类型
    实现的所有接口
    Serializable ， Cloneable ， Iterable<E> ， Collection<E> ， List<E> ， RandomAccess
    已知直接子类：
    Stack 
    public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable
    Vector类实现了可增长的对象数组。 像数组一样，它包含可以使用整数索引访问的组件。 但是， Vector的大小可以根据需要增大或缩小，以便在创建Vector后添加和删除项目。

    每个向量都尝试通过维护capacity和capacityIncrement来优化存储管理。 capacity始终至少与矢量大小一样大; 它通常更大，因为当组件被添加到向量时，向量的存储以块大小增加capacityIncrement 。 应用程序可以在插入大量组件之前增加向量的容量; 这减少了增量重新分配的数量。

    此类的iterator和listIterator方法返回的迭代器是快速失败的 ：如果在创建迭代器之后的任何时候对向量进行结构修改，除了通过迭代器自己的remove或add方法之外，迭代器将抛出ConcurrentModificationException 。 因此，在并发修改的情况下，迭代器快速而干净地失败，而不是在未来的未确定时间冒任意，非确定性行为的风险。 该Enumerations由返回elements方法不是快速失败的; 如果在创建枚举后的任何时候对Vector进行结构修改，则枚举的结果是未定义的。

    请注意，迭代器的快速失败行为无法得到保证，因为一般来说，在存在不同步的并发修改时，不可能做出任何硬性保证。 失败快速迭代器以尽力而为的方式抛出ConcurrentModificationException 。 因此，编写依赖于此异常的程序以确保其正确性是错误的： 迭代器的快速失败行为应该仅用于检测错误。

    从Java 2平台v1.2开始，该类被改进以实现List接口，使其成为Java Collections Framework的成员。 与新的集合实现不同， Vector是同步的。 如果不需要线程安全实现，建议使用ArrayList代替Vector 。

    从以下版本开始：
    1.0
    另请参见：
    Collection ， LinkedList ， Serialized Form

    • 字段汇总

      字段  
      变量和类型 字段 描述
      protected int capacityIncrement
      当矢量大小超过其容量时，矢量容量自动递增的量。
      protected int elementCount
      此 Vector对象中的有效组件数。
      protected Object[] elementData
      存储向量组件的数组缓冲区。

    • 构造方法摘要

      构造方法  
      构造器 描述
      Vector()
      构造一个空向量，使其内部数据数组的大小为 10 ，其标准容量增量为零。
      Vector​(int initialCapacity)
      构造一个具有指定初始容量且容量增量等于零的空向量。
      Vector​(int initialCapacity, int capacityIncrement)
      构造具有指定初始容量和容量增量的空向量。
      Vector​(Collection<? extends E> c)
      按照集合的迭代器返回的顺序构造一个包含指定集合元素的向量。

    • 方法摘要

      所有方法  实例方法 具体的方法 
      变量和类型 方法 描述
      void add​(int index, E element)
      将指定元素插入此Vector中的指定位置。
      boolean add​(E e)
      将指定的元素追加到此Vector的末尾。
      boolean addAll​(int index, Collection<? extends E> c)
      将指定Collection中的所有元素插入到此Vector中的指定位置。
      boolean addAll​(Collection<? extends E> c)
      将指定Collection中的所有元素追加到此Vector的末尾，按照指定Collection的Iterator返回的顺序。
      void addElement​(E obj)
      将指定的组件添加到此向量的末尾，将其大小增加1。
      int capacity()
      返回此向量的当前容量。
      void clear()
      从此Vector中删除所有元素。
      Object clone()
      返回此向量的副本。
      boolean contains​(Object o)
      如果此向量包含指定的元素，则返回 true 。
      boolean containsAll​(Collection<?> c)
      如果此Vector包含指定Collection中的所有元素，则返回true。
      void copyInto​(Object[] anArray)
      将此向量的组件复制到指定的数组中。
      E elementAt​(int index)
      返回指定索引处的组件。
      Enumeration<E> elements()
      返回此向量的组件的枚举。
      void ensureCapacity​(int minCapacity)
      如有必要，增加此向量的容量，以确保它至少可以容纳由minimum capacity参数指定的组件数。
      boolean equals​(Object o)
      将指定的Object与此Vector进行比较以获得相等性。
      E firstElement()
      返回此向量的第一个组件（索引 0处的项）。
      void forEach​(Consumer<? super E> action)
      对 Iterable每个元素执行给定操作，直到处理 Iterable所有元素或操作引发异常。
      E get​(int index)
      返回此Vector中指定位置的元素。
      int hashCode()
      返回此Vector的哈希码值。
      int indexOf​(Object o)
      返回此向量中第一次出现的指定元素的索引，如果此向量不包含该元素，则返回-1。
      int indexOf​(Object o, int index)
      返回此向量中第一次出现的指定元素的索引，从 index向前搜索，如果找不到该元素，则返回-1。
      void insertElementAt​(E obj, int index)
      将指定对象作为此向量中的组件插入指定的 index 。
      boolean isEmpty()
      测试此向量是否没有组件。
      Iterator<E> iterator()
      以适当的顺序返回此列表中元素的迭代器。
      E lastElement()
      返回向量的最后一个组件。
      int lastIndexOf​(Object o)
      返回此向量中指定元素最后一次出现的索引，如果此向量不包含该元素，则返回-1。
      int lastIndexOf​(Object o, int index)
      返回此向量中最后一次出现的指定元素的索引，从 index向后搜索，如果找不到该元素，则返回-1。
      ListIterator<E> listIterator()
      返回此列表中元素的列表迭代器（按适当顺序）。
      ListIterator<E> listIterator​(int index)
      从列表中的指定位置开始，返回列表中元素的列表迭代器（按正确顺序）。
      E remove​(int index)
      删除此Vector中指定位置的元素。
      boolean remove​(Object o)
      删除此向量中第一次出现的指定元素如果向量不包含该元素，则不会更改。
      boolean removeAll​(Collection<?> c)
      从此Vector中删除指定Collection中包含的所有元素。
      void removeAllElements()
      从此向量中移除所有组件并将其大小设置为零。
      boolean removeElement​(Object obj)
      从此向量中移除参数的第一个（索引最低）事件。
      void removeElementAt​(int index)
      删除指定索引处的组件。
      boolean removeIf​(Predicate<? super E> filter)
      删除此集合中满足给定谓词的所有元素。
      protected void removeRange​(int fromIndex, int toIndex)
      从此列表中删除索引介于 fromIndex （含）和 toIndex （独占）之间的所有元素。
      void replaceAll​(UnaryOperator<E> operator)
      将该列表的每个元素替换为将运算符应用于该元素的结果。
      boolean retainAll​(Collection<?> c)
      仅保留此Vector中包含在指定Collection中的元素。
      E set​(int index, E element)
      用指定的元素替换此Vector中指定位置的元素。
      void setElementAt​(E obj, int index)
      将此向量的指定 index处的组件设置为指定对象。
      void setSize​(int newSize)
      设置此向量的大小。
      int size()
      返回此向量中的组件数。
      Spliterator<E> spliterator()
      在此列表中的元素上创建late-binding和失败快速 Spliterator 。
      List<E> subList​(int fromIndex, int toIndex)
      返回此List的部分在fromIndex（包含）和toIndex（独占）之间的视图。
      Object[] toArray()
      以正确的顺序返回包含此Vector中所有元素的数组。
      <T> T[] toArray​(T[] a)
      以正确的顺序返回包含此Vector中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。
      String toString()
      返回此Vector的字符串表示形式，包含每个元素的String表示形式。
      void trimToSize()
      修剪此向量的容量为向量的当前大小。

    • 字段详细信息

      • elementData

        protected Object[] elementData
        存储向量组件的数组缓冲区。 向量的容量是此数组缓冲区的长度，并且至少足以包含所有向量的元素。

        Vector中最后一个元素后面的任何数组元素都是null。

      • elementCount

        protected int elementCount
        此Vector对象中的有效组件数。 组件elementData[0]到elementData[elementCount-1]是实际的项目。

      • capacityIncrement

        protected int capacityIncrement
        当矢量大小超过其容量时，矢量容量自动递增的量。 如果容量增量小于或等于零，则每次需要增长时，矢量的容量加倍。

    • 构造方法详细信息

      • Vector

        public Vector​(int initialCapacity,
              int capacityIncrement)
        构造具有指定初始容量和容量增量的空向量。
        参数
        initialCapacity - 向量的初始容量
        capacityIncrement - 向量溢出时容量增加的量
        异常
        IllegalArgumentException - 如果指定的初始容量为负数

      • Vector

        public Vector​(int initialCapacity)
        构造一个具有指定初始容量且容量增量等于零的空向量。
        参数
        initialCapacity - 向量的初始容量
        异常
        IllegalArgumentException - 如果指定的初始容量为负数

      • Vector

        public Vector()
        构造一个空向量，使其内部数据数组的大小为 10 ，其标准容量增量为零。

      • Vector

        public Vector​(Collection<? extends E> c)
        按照集合的迭代器返回的顺序构造一个包含指定集合元素的向量。
        参数
        c - c元素放入此向量的集合
        异常
        NullPointerException - 如果指定的集合为null
        从以下版本开始：
        1.2

    • 方法详细信息

      • copyInto

        public void copyInto​(Object[] anArray)
        将此向量的组件复制到指定的数组中。 在索引项k该向量被复制到部件k的anArray 。
        参数
        anArray - 组件复制到的数组
        异常
        NullPointerException - 如果给定数组为null
        IndexOutOfBoundsException - 如果指定的数组不足以容纳此向量的所有组件
        ArrayStoreException - 如果此向量的组件不是可以存储在指定数组中的运行时类型
        另请参见：
        toArray(Object[])

      • trimToSize

        public void trimToSize()
        修剪此向量的容量为向量的当前大小。 如果此向量的容量大于其当前大小，则通过将字段elementData保留的内部数据数组替换为较小的容量，将容量更改为等于大小。 应用程序可以使用此操作来最小化向量的存储。

      • ensureCapacity

        public void ensureCapacity​(int minCapacity)
        如有必要，增加此向量的容量，以确保它至少可以容纳由minimum capacity参数指定的组件数。

        如果此向量的当前容量小于minCapacity ，则通过将更大的内部数据阵列保留在字段elementData来增加其容量。 新的数据阵列的大小将是原来的大小加上capacityIncrement ，除非的值capacityIncrement小于或等于零，在这种情况下，新的容量将是原来容量的两倍; 但如果这个新尺寸仍小于minCapacity ，则新容量将为minCapacity 。

        参数
        minCapacity - 所需的最小容量

      • setSize

        public void setSize​(int newSize)
        设置此向量的大小。 如果新大小大于当前大小， null在向量的末尾添加新的null项。 如果新大小小于当前大小，则丢弃索引为newSize或更大的所有组件。
        参数
        newSize - 此向量的新大小
        异常
        ArrayIndexOutOfBoundsException - 如果新大小为负数

      • capacity

        public int capacity()
        返回此向量的当前容量。
        结果
        当前容量（其内部数据数组的长度，保存在此向量的字段 elementData中）

      • size

        public int size()
        返回此向量中的组件数。
        Specified by:
        size在界面 Collection<E>
        Specified by:
        size在界面 List<E>
        结果
        此向量中的组件数

      • isEmpty

        public boolean isEmpty()
        测试此向量是否没有组件。
        Specified by:
        isEmpty在界面 Collection<E>
        Specified by:
        isEmpty在界面 List<E>
        重写：
        isEmpty在类 AbstractCollection<E>
        结果
        true当且仅当此向量没有组件时，即其大小为零; 否则为false 。

      • elements

        public Enumeration<E> elements()
        返回此向量的组件的枚举。 返回的Enumeration对象将生成此向量中的所有项目。 生成的第一个项目是索引0处的项目，然后是索引1处的项目，依此类推。 如果在枚举元素的同时对结构进行了结构修改，则枚举的结果是未定义的。
        结果
        这个向量的组件的枚举
        另请参见：
        Iterator

      • contains

        public boolean contains​(Object o)
        如果此向量包含指定的元素，则返回true 。 更正式地，返回true当且仅当此向量包含至少一个元素e Objects.equals(o, e) 。
        Specified by:
        contains接口 Collection<E>
        Specified by:
        contains在界面 List<E>
        重写：
        contains在类 AbstractCollection<E>
        参数
        o - 要测试其在此向量中的存在的元素
        结果
        true如果此向量包含指定的元素

      • indexOf

        public int indexOf​(Object o)
        返回此向量中第一次出现的指定元素的索引，如果此向量不包含该元素，则返回-1。 更正式地，返回最低指数i如Objects.equals(o, get(i)) ，如果没有这样的指数，则返回-1。
        Specified by:
        indexOf在界面 List<E>
        重写：
        indexOf在类 AbstractList<E>
        参数
        o - 要搜索的元素
        结果
        此向量中第一次出现指定元素的索引，如果此向量不包含该元素，则返回-1

      • indexOf

        public int indexOf​(Object o,
                   int index)
        返回此向量中第一次出现的指定元素的索引，从index搜索向前，或者如果找不到该元素则返回-1。 更正式的是，返回最低指数i如(i >= index && Objects.equals(o, get(i))) ，如果没有这样的指数则返回-1。
        参数
        o - 要搜索的元素
        index - 开始搜索的索引
        结果
        此向量中元素在位置index或更高位置的第一次出现的索引; -1如果找不到该元素。
        异常
        IndexOutOfBoundsException - 如果指定的索引为负数
        另请参见：
        Object.equals(Object)

      • lastIndexOf

        public int lastIndexOf​(Object o)
        返回此向量中指定元素最后一次出现的索引，如果此向量不包含该元素，则返回-1。 更正式地说，返回最高指数i如Objects.equals(o, get(i)) ，如果没有这样的指数则返回-1。
        Specified by:
        lastIndexOf在界面 List<E>
        重写：
        lastIndexOf在类 AbstractList<E>
        参数
        o - 要搜索的元素
        结果
        此向量中指定元素最后一次出现的索引，如果此向量不包含该元素，则返回-1

      • lastIndexOf

        public int lastIndexOf​(Object o,
                       int index)
        返回此向量中最后一次出现的指定元素的索引，从index向后搜索，如果找不到该元素，则返回-1。 更正式的是，返回最高指数i如(i <= index && Objects.equals(o, get(i))) ，如果没有这样的指数则返回-1。
        参数
        o - 要搜索的元素
        index - 开始向后搜索的索引
        结果
        此向量中位置小于或等于index的元素的最后一次出现的索引; 如果找不到元素，则返回-1。
        异常
        IndexOutOfBoundsException - 如果指定的索引大于或等于此向量的当前大小

      • elementAt

        public E elementAt​(int index)
        返回指定索引处的组件。

        此方法的功能与get(int)方法（ List接口的一部分）相同。

        参数
        index - 此向量的索引
        结果
        指定索引处的组件
        异常
        ArrayIndexOutOfBoundsException - 如果指数超出范围（ index < 0 || index >= size() ）

      • firstElement

        public E firstElement()
        返回此向量的第一个组件（索引为 0的项）。
        结果
        这个载体的第一个组成部分
        异常
        NoSuchElementException - 如果此向量没有组件

      • lastElement

        public E lastElement()
        返回向量的最后一个组件。
        结果
        向量的最后一个组成部分，即索引为 size() - 1的组件
        异常
        NoSuchElementException - 如果此向量为空

      • setElementAt

        public void setElementAt​(E obj,
                         int index)
        将此向量的指定index处的组件设置为指定对象。 该位置的前一个组件将被丢弃。

        索引必须是大于或等于0且小于向量当前大小的值。

        此方法的功能与set(int, E)方法（ List接口的一部分）相同。 请注意， set方法会反转参数的顺序，以更接近地匹配数组使用情况。 另请注意， set方法返回存储在指定位置的旧值。

        参数
        obj - obj组件设置为什么
        index - 指定的索引
        异常
        ArrayIndexOutOfBoundsException - 如果指数超出范围（ index < 0 || index >= size() ）

      • removeElementAt

        public void removeElementAt​(int index)
        删除指定索引处的组件。 索引中大于或等于指定值index此向量中的每个分量向下移动，使索引1小于先前的值。 此向量的大小减少1 。

        索引必须是大于或等于0且小于向量当前大小的值。

        此方法的功能与remove(int)方法（ List接口的一部分）相同。 请注意， remove方法返回存储在指定位置的旧值。

        参数
        index - 要删除的对象的索引
        异常
        ArrayIndexOutOfBoundsException - 如果指数超出范围（ index < 0 || index >= size() ）

      • insertElementAt

        public void insertElementAt​(E obj,
                            int index)
        将指定对象作为此向量中的组件插入指定的index 。 索引中大于或等于指定值index此向量中的每个分量向上移动，使索引1大于先前的值。

        索引必须是大于或等于0且小于或等于向量当前大小的值。 （如果索引等于向量的当前大小，则新元素将附加到Vector。）

        此方法的功能与add(int, E)方法（ List接口的一部分）相同。 请注意， add方法会反转参数的顺序，以更接近地匹配数组使用情况。

        参数
        obj - 要插入的组件
        index - 插入新组件的位置
        异常
        ArrayIndexOutOfBoundsException - 如果指数超出范围（ index < 0 || index > size() ）

      • addElement

        public void addElement​(E obj)
        将指定的组件添加到此向量的末尾，将其大小增加1。 如果该载体的大小大于其容量，则该载体的容量会增加。

        此方法的功能与add(E)方法（ List接口的一部分）相同。

        参数
        obj - 要添加的组件

      • removeElement

        public boolean removeElement​(Object obj)
        从此向量中移除参数的第一个（索引最低）事件。 如果在此向量中找到对象，则向量中具有大于或等于对象索引的索引的每个组件向下移动以使索引1小于其先前的值。

        此方法的功能与remove(Object)方法（ List接口的一部分）相同。

        参数
        obj - 要删除的组件
        结果
        true如果参数是该向量的一个组成部分; 否则为false 。

      • removeAllElements

        public void removeAllElements()
        从此向量中移除所有组件并将其大小设置为零。

        此方法的功能与clear()方法（ List接口的一部分）相同。

      • clone

        public Object clone()
        返回此向量的副本。 该副本将包含对内部数据数组的克隆的引用，而不是对此Vector对象的原始内部数据数组的Vector 。
        重写：
        clone在类 Object
        结果
        这个载体的克隆
        另请参见：
        Cloneable

      • toArray

        public <T> T[] toArray​(T[] a)
        以正确的顺序返回包含此Vector中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。 如果Vector适合指定的数组，则返回其中。 否则，将使用指定数组的运行时类型和此Vector的大小分配新数组。

        如果Vector适合指定的数组，并且有空余空间（即数组中的元素多于Vector），则紧跟Vector结尾的数组中的元素将设置为null。 （ 仅当调用者知道Vector不包含任何null元素时，这在确定Vector的长度时很有用。）

        Specified by:
        toArray在界面 Collection<E>
        Specified by:
        toArray在界面 List<E>
        重写：
        toArray在类 AbstractCollection<E>
        参数类型
        T - 数组元素的类型。 与<E>相同或超类型为<E> 。
        参数
        a - 要存储Vector元素的数组（如果它足够大）; 否则，为此目的分配相同运行时类型的新数组。
        结果
        包含Vector元素的数组
        异常
        ArrayStoreException - 如果a的运行时类型 <T>不是此向量中每个元素的运行时类型的超类型 <E>
        NullPointerException - 如果给定数组为null
        从以下版本开始：
        1.2

      • get

        public E get​(int index)
        返回此Vector中指定位置的元素。
        Specified by:
        get在界面 List<E>
        Specified by:
        get在类 AbstractList<E>
        参数
        index - 要返回的元素的索引
        结果
        指定索引处的对象
        异常
        ArrayIndexOutOfBoundsException - 如果指数超出范围（ index < 0 || index >= size() ）
        从以下版本开始：
        1.2

      • set

        public E set​(int index,
             E element)
        用指定的元素替换此Vector中指定位置的元素。
        Specified by:
        set在界面 List<E>
        重写：
        set在类 AbstractList<E>
        参数
        index - 要替换的元素的索引
        element - 要存储在指定位置的元素
        结果
        先前在指定位置的元素
        异常
        ArrayIndexOutOfBoundsException - 如果索引超出范围（ index < 0 || index >= size() ）
        从以下版本开始：
        1.2

      • add

        public boolean add​(E e)
        将指定的元素追加到此Vector的末尾。
        Specified by:
        add在界面 Collection<E>
        Specified by:
        add在界面 List<E>
        重写：
        add在类 AbstractList<E>
        参数
        e - 要附加到此Vector的元素
        结果
        true （由 Collection.add(E)指定）
        从以下版本开始：
        1.2

      • remove

        public boolean remove​(Object o)
        删除此向量中第一次出现的指定元素如果向量不包含该元素，则不会更改。 更正式地，删除具有最低索引i的元素，使得Objects.equals(o, get(i)) （如果存在这样的元素）。
        Specified by:
        remove在界面 Collection<E>
        Specified by:
        remove in interface List<E>
        重写：
        remove在类 AbstractCollection<E>
        参数
        o - 要从此Vector中移除的元素（如果存在）
        结果
        如果Vector包含指定的元素，则为true
        从以下版本开始：
        1.2

      • add

        public void add​(int index,
                E element)
        将指定元素插入此Vector中的指定位置。 将当前位置的元素（如果有）和任何后续元素向右移动（将其添加到索引中）。
        Specified by:
        add在界面 List<E>
        重写：
        add在类 AbstractList<E>
        参数
        index - 要插入指定元素的索引
        element - 要插入的元素
        异常
        ArrayIndexOutOfBoundsException - 如果指数超出范围（ index < 0 || index > size() ）
        从以下版本开始：
        1.2

      • remove

        public E remove​(int index)
        删除此Vector中指定位置的元素。 将任何后续元素向左移位（从索引中减去一个元素）。 返回从Vector中删除的元素。
        Specified by:
        remove在界面 List<E>
        重写：
        remove在 AbstractList<E>类
        参数
        index - 要删除的元素的索引
        结果
        被删除的元素
        异常
        ArrayIndexOutOfBoundsException - 如果指数超出范围（ index < 0 || index >= size() ）
        从以下版本开始：
        1.2

      • clear

        public void clear()
        从此Vector中删除所有元素。 此调用返回后，Vector将为空（除非它抛出异常）。
        Specified by:
        clear在界面 Collection<E>
        Specified by:
        clear在界面 List<E>
        重写：
        clear在类 AbstractList<E>
        从以下版本开始：
        1.2

      • addAll

        public boolean addAll​(Collection<? extends E> c)
        将指定Collection中的所有元素追加到此Vector的末尾，按照指定Collection的Iterator返回的顺序。 如果在操作正在进行时修改了指定的Collection，则此操作的行为是不确定的。 （这意味着如果指定的Collection是此Vector，则此调用的行为是未定义的，并且此Vector非空。）
        Specified by:
        addAll在界面 Collection<E>
        Specified by:
        addAll在界面 List<E>
        重写：
        addAll在类 AbstractCollection<E>
        参数
        c - 要插入此Vector的元素
        结果
        true如果此向量因调用而更改
        异常
        NullPointerException - 如果指定的集合为null
        从以下版本开始：
        1.2
        另请参见：
        AbstractCollection.add(Object)

      • removeIf

        public boolean removeIf​(Predicate<? super E> filter)
        从界面复制的说明： Collection
        删除此集合中满足给定谓词的所有元素。 在迭代期间或通过谓词抛出的错误或运行时异常被中继到调用者。
        Specified by:
        removeIf接口 Collection<E>
        参数
        filter - 一个谓词，它返回 true表示要删除的元素
        结果
        true如果删除了任何元素
        异常
        NullPointerException - 如果指定的过滤器为null

      • addAll

        public boolean addAll​(int index,
                      Collection<? extends E> c)
        将指定Collection中的所有元素插入到此Vector中的指定位置。 将当前位置的元素（如果有）和任何后续元素向右移动（增加其索引）。 新元素将按照指定Collection的迭代器返回的顺序出现在Vector中。
        Specified by:
        addAll在界面 List<E>
        重写：
        addAll在类 AbstractList<E>
        参数
        index - 从指定集合插入第一个元素的索引
        c - 要插入此Vector中的元素
        结果
        true如果此向量因调用而更改
        异常
        ArrayIndexOutOfBoundsException - 如果指数超出范围（ index < 0 || index > size() ）
        NullPointerException - 如果指定的集合为null
        从以下版本开始：
        1.2

      • equals

        public boolean equals​(Object o)
        将指定的Object与此Vector进行比较以获得相等性。 当且仅当指定的Object也是List时，返回true，两个列表具有相同的大小，并且两个列表中的所有对应元素对都相等 。 （两个元件e1和e2是如果相等 Objects.equals(e1, e2) ）。换句话说，两个列表被定义为等于如果它们包含以相同的顺序相同的元件。
        Specified by:
        equals在界面 Collection<E>
        Specified by:
        equals在界面 List<E>
        重写：
        equals在类 AbstractList<E>
        参数
        o - 要与此Vector进行相等性比较的对象
        结果
        如果指定的Object等于此Vector，则返回true
        另请参见：
        Object.hashCode() ， HashMap

      • toString

        public String toString()
        返回此Vector的字符串表示形式，包含每个元素的String表示形式。
        重写：
        toString在类 AbstractCollection<E>
        结果
        此集合的字符串表示形式

      • subList

        public List<E> subList​(int fromIndex,
                       int toIndex)
        返回此List的部分在fromIndex（包含）和toIndex（独占）之间的视图。 （如果fromIndex和toIndex相等，则返回的List为空。）返回的List由此List支持，因此返回List中的更改将反映在此List中，反之亦然。 返回的List支持此List支持的所有可选List操作。

        此方法消除了对显式范围操作的需要（对于数组通常存在的排序）。 任何期望List的操作都可以通过操作subList视图而不是整个List来用作范围操作。 例如，以下习语从List中删除了一系列元素： 

          list.subList(from, to).clear();
        可以为indexOf和lastIndexOf构造类似的习语，并且可以将Collections类中的所有算法应用于subList。

        如果支持列表（即此List）在结构上以除了返回List之外的任何方式进行变量 ，则此方法返回的List的语义将变为未定义。 （结构修改是那些改变列表大小的修改，或以其他方式扰乱它，使得正在进行的迭代可能产生不正确的结果。）

        Specified by:
        subList在界面 List<E>
        重写：
        subList在类 AbstractList<E>
        参数
        fromIndex - fromIndex低端点（包括）
        toIndex - toIndex高端点（不包括）
        结果
        此列表中指定范围的视图
        异常
        IndexOutOfBoundsException - 如果端点索引值超出范围 (fromIndex < 0 || toIndex > size)
        IllegalArgumentException - 如果端点索引无序 (fromIndex > toIndex)

      • removeRange

        protected void removeRange​(int fromIndex,
                           int toIndex)
        从此列表中删除索引介于fromIndex （含）和toIndex （独占）之间的所有元素。 将任何后续元素向左移动（降低其索引）。 此调用通过(toIndex - fromIndex)元素缩短列表。 （如果是toIndex==fromIndex ，则此操作无效。）
        重写：
        removeRange在 AbstractList<E>类
        参数
        fromIndex - 要删除的第一个元素的索引
        toIndex - 要删除的最后一个元素之后的索引

      • listIterator

        public ListIterator<E> listIterator​(int index)
        从列表中的指定位置开始，返回列表中元素的列表迭代器（按正确顺序）。 指定的索引指示初始调用next将返回的第一个元素。 对previous的初始调用将返回指定索引减去1的元素。

        返回的列表迭代器是fail-fast 。

        Specified by:
        listIterator在界面 List<E>
        重写：
        listIterator ，类 AbstractList<E>
        参数
        index - 从列表迭代器返回的第一个元素的索引（通过调用 next ）
        结果
        列表中元素的列表迭代器（按正确顺序），从列表中的指定位置开始
        异常
        IndexOutOfBoundsException - 如果指数超出范围（ index < 0 || index > size() ）

      • forEach

        public void forEach​(Consumer<? super E> action)
        从界面复制的说明： Iterable
        对Iterable每个元素执行给定操作，直到处理Iterable所有元素或操作抛出异常为止。 如果指定了该顺序，则按迭代顺序执行操作。 操作抛出的异常将转发给调用者。

        如果操作执行修改元素的基础源的副作用，则此方法的行为未指定，除非重写类已指定并发修改策略。

        Specified by:
        forEach接口 Iterable<E>
        参数
        action - 要为每个元素执行的操作
        异常
        NullPointerException - 如果指定的操作为null

      • replaceAll

        public void replaceAll​(UnaryOperator<E> operator)
        从界面复制的说明： List
        将该列表的每个元素替换为将运算符应用于该元素的结果。 操作员抛出的错误或运行时异常将转发给调用者。
        Specified by:
        replaceAll在界面 List<E>
        参数
        operator - 要应用于每个元素的运算符
        异常
        NullPointerException - 如果指定的运算符为null或运算符结果为空值且此列表不允许空元素（ optional ）