Module  java.base
软件包  java.util

Class Vector<E>

  • 参数类型
    E - 组件元素的类型
    All Implemented Interfaces:
    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扔掉ConcurrentModificationException 。 因此，编写依赖于此异常的程序的正确性将是错误的： 迭代器的故障快速行为应仅用于检测错误。

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

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

    • Field Summary

      Fields  
      Modifier and Type Field 描述
      protected int capacityIncrement
      当矢量的大小大于其容量时，矢量的容量自动增加的量。
      protected int elementCount
      此 Vector对象中有效组件的数量。
      protected Object[] elementData
      存储向量的组件的阵列缓冲区。

    • 构造方法摘要

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

    • 方法摘要

      所有方法  接口方法  具体的方法 
      Modifier and Type 方法 描述
      void add​(int index, E element)
      在此Vector中的指定位置插入指定的元素。
      boolean add​(E e)
      将指定的元素追加到此Vector的末尾。
      boolean addAll​(int index, Collection<? extends E> c)
      将指定集合中的所有元素插入到此向量中的指定位置。
      boolean addAll​(Collection<? extends E> c)
      将指定集合中的所有元素追加到该向量的末尾，按照它们由指定集合的迭代器返回的顺序。
      void addElement​(E obj)
      将指定的组件添加到此向量的末尾，将其大小增加1。
      int capacity​()
      返回此向量的当前容量。
      void clear​()
      从此Vector中删除所有元素。
      Object clone​()
      返回此向量的克隆。
      boolean contains​(Object o)
      如果此向量包含指定的元素，则返回 true 。
      boolean containsAll​(Collection<?> c)
      如果此向量包含指定集合中的所有元素，则返回true。
      void copyInto​(Object[] anArray)
      将此向量的组件复制到指定的数组中。
      E elementAt​(int index)
      返回指定索引处的组件。
      Enumeration<E> elements​()
      返回此向量的组件的枚举。
      void ensureCapacity​(int minCapacity)
      如果需要，增加此向量的容量，以确保它可以至少保存最小容量参数指定的组件数。
      boolean equals​(Object o)
      将指定的对象与此向量进行比较以获得相等性。
      E firstElement​()
      返回此向量的第一个组件（索引号为 0的项目）。
      void forEach​(Consumer<? super E> action)
      对 Iterable每个元素执行给定的操作，直到所有元素都被处理或者动作引发异常。
      E get​(int index)
      返回此向量中指定位置的元素。
      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)
      删除此向量中指定位置的元素。
      boolean remove​(Object o)
      删除此向量中指定元素的第一个出现如果Vector不包含元素，则它不会更改。
      boolean removeAll​(Collection<?> c)
      从此Vector中删除指定集合中包含的所有元素。
      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)
      仅保留此向量中包含在指定集合中的元素。
      E set​(int index, E element)
      用指定的元素替换此Vector中指定位置的元素。
      void setElementAt​(E obj, int index)
      将此向量的指定 index中的组件设置为指定的对象。
      void setSize​(int newSize)
      设置此向量的大小。
      int size​()
      返回此向量中的组件数。
      void sort​(Comparator<? super E> c)
      根据指定的Comparator引发的顺序排列此列表。
      Spliterator<E> spliterator​()
      在此列表中的元素上创建late-binding和故障快速 Spliterator 。
      List<E> subList​(int fromIndex, int toIndex)
      返回此列表之间的fromIndex（包括）和toIndex之间的独占视图。
      Object[] toArray​()
      以正确的顺序返回一个包含此Vector中所有元素的数组。
      <T> T[] toArray​(T[] a)
      以正确的顺序返回一个包含此Vector中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。
      String toString​()
      返回此Vector的字符串表示形式，其中包含每个元素的String表示形式。
      void trimToSize​()
      修改该向量的容量成为向量的当前大小。

    • 字段详细信息

      • elementData

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

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

      • 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 - 如果指定的集合为空
        从以下版本开始：
        1.2

    • 方法详细信息

      • copyInto

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

      • trimToSize

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

      • ensureCapacity

        public void ensureCapacity​(int minCapacity)
        如果需要，增加此向量的容量，以确保它可以至少保存最小容量参数指定的组件数。

        如果该向量的当前容量小于minCapacity ，则通过将其内部数据阵列替换为elementData的较大的数据阵列来增加其容量。 新的数据阵列的大小将是原来的大小加上capacityIncrement ，除非的值capacityIncrement小于或等于零，在这种情况下，新的容量将是原来容量的两倍; 但是如果这个新的大小仍然小于minCapacity ，那么新的容量将是minCapacity 。

        参数
        minCapacity - 所需的最小容量

      • setSize

        public void setSize​(int newSize)
        设置此向量的大小。 如果新尺寸大于当前大小，则新的null项目将添加到向量的末尾。 如果新大小小于当前大小， newSize丢弃索引为newSize及更高版本的所有组件。
        参数
        newSize - 这个矢量的新的大小
        异常
        ArrayIndexOutOfBoundsException - 如果新大小为负数

      • capacity

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

      • 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 - 要设置的组件
        index - 指定的索引
        异常
        ArrayIndexOutOfBoundsException - 如果索引超出范围（ index < 0 || index >= size() ）

      • removeElementAt

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

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

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

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

      • insertElementAt

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

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

        该方法的功能与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)
        从此向量中删除参数的第一个（最低索引）出现次数。 如果在该向量中找到对象，则向量中具有大于或等于对象索引的索引的向量中的每个组件向下移动，以使索引小于之前的值。

        该方法在功能上与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结束之后的数组中的元素将设置为null。 （ 仅当调用者知道Vector不包含任何空元素时，这才有助于确定Vector的长度。）

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

      • get

        public E get​(int index)
        返回此向量中指定位置的元素。
        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 - 要附加到此向量的元素
        结果
        true （由 Collection.add(E)指定）
        从以下版本开始：
        1.2

      • remove

        public boolean remove​(Object o)
        删除此向量中指定元素的第一个出现如果Vector不包含元素，则它不会更改。 更正式地，删除具有最低索引i的元素，使得Objects.equals(o, get(i)) （如果这样的元素存在）。
        Specified by:
        remove在接口 Collection<E>
        Specified by:
        remove在接口 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中删除的元素。
        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)
        将指定集合中的所有元素追加到该向量的末尾，按照它们由指定集合的迭代器返回的顺序。 如果在操作进行中修改了指定的集合，则此操作的行为是未定义的。 （这意味着如果指定的集合是此Vector，则此调用的行为是未定义的，并且此向量是非空的。）
        Specified by:
        addAll在接口 Collection<E>
        Specified by:
        addAll在接口 List<E>
        重写：
        addAll在 AbstractCollection<E>
        参数
        c - 要插入此向量的元素
        结果
        true如果此向量由于调用而更改
        异常
        NullPointerException - 如果指定的集合为空
        从以下版本开始：
        1.2
        另请参见：
        AbstractCollection.add(Object)

      • removeIf

        public boolean removeIf​(Predicate<? super E> filter)
        描述从接口Collection复制
        删除满足给定谓词的此集合的所有元素。 在迭代或谓词中抛出的错误或运行时异常被转发给调用者。
        Specified by:
        removeIf在接口 Collection<E>
        参数
        filter - 为要删除的元素返回 true的谓词
        结果
        true如果有任何元素被删除
        异常
        NullPointerException - 如果指定的过滤器为空

      • addAll

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

      • equals

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

      • toString

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

      • subList

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

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

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

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

        Specified by:
        subList在接口 List<E>
        重写：
        subList在 AbstractList<E>
        参数
        fromIndex - 子列表的低端点（含）
        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每个元素执行给定的操作，直到所有元素都被处理或者动作引发异常。 如果指定了该顺序，则按迭代的顺序执行操作。 动作抛出的异常被转发给呼叫者。

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

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

      • replaceAll

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

      • sort

        public void sort​(Comparator<? super E> c)
        说明从接口List复制
        根据指定的Comparator引发的顺序排列此列表。

        该列表中的所有元素必须使用指定的比较器相互比较（即， c.compare(e1, e2)不得为ClassCastException中的任何元素e1和e2抛出ClassCastException ）。

        如果指定的比较器是null则该列表中的所有元素都必须实现Comparable接口，并且应使用元素' natural ordering '。

        该列表必须是可修改的，但不能调整大小。

        Specified by:
        sort在接口 List<E>
        参数
        c - Comparator用于比较列表元素。 A null值表示应使用元素' natural ordering '