模块  java.base
软件包  java.util

Class ArrayDeque<E>

  • 参数类型
    E - 此双端队列中保留的元素类型
    实现的所有接口
    Serializable ， Cloneable ， Iterable<E> ， Collection<E> ， Deque<E> ， Queue<E> 
    public class ArrayDeque<E>
extends AbstractCollection<E>
implements Deque<E>, Cloneable, Serializable
    Deque接口的可调整大小的阵列实现。 阵列deques没有容量限制; 他们根据需要增长以支持使用。 它们不是线程安全的; 在没有外部同步的情况下，它们不支持多线程的并发访问。 禁止使用空元素。 当用作堆栈时， 此类可能比Stack更快，并且当用作队列时速度快于LinkedList 。

    大多数ArrayDeque操作以摊还的常量时间运行。 例外包括remove ， removeFirstOccurrence ， removeLastOccurrence ， contains ， iterator.remove() ，和批量操作，所有这些都在运行线性时间。

    这个类的iterator方法返回的迭代器是快速失败的 ：如果在创建迭代器之后的任何时候修改了deque，除了通过迭代器自己的remove方法之外，迭代器通常会抛出ConcurrentModificationException 。 因此，在并发修改的情况下，迭代器快速而干净地失败，而不是在未来的未确定时间冒任意，非确定性行为的风险。

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

    该类及其迭代器实现了Collection和Iterator接口的所有可选方法。

    此类是Java Collections Framework的成员。

    从以下版本开始：
    1.6
    另请参见：
    Serialized Form

    • 构造方法摘要

      构造方法  
      构造器 描述
      ArrayDeque()
      构造一个空数组deque，其初始容量足以容纳16个元素。
      ArrayDeque​(int numElements)
      构造一个空数组deque，其初始容量足以容纳指定数量的元素。
      ArrayDeque​(Collection<? extends E> c)
      按照集合的迭代器返回的顺序构造一个包含指定集合元素的双端队列。

    • 方法摘要

      所有方法  实例方法 具体的方法 
      变量和类型 方法 描述
      boolean add​(E e)
      在此双端队列的末尾插入指定的元素。
      boolean addAll​(Collection<? extends E> c)
      在此双端队列的末尾添加指定集合中的所有元素，就好像通过在每个双 端子上调用 addLast(E)一样 ，按照集合的迭代器返回它们的顺序。
      void addFirst​(E e)
      在此双端队列的前面插入指定的元素。
      void addLast​(E e)
      在此双端队列的末尾插入指定的元素。
      void clear()
      从此双端队列中删除所有元素。
      ArrayDeque<E> clone()
      返回此双端队列的副本。
      boolean contains​(Object o)
      如果此双端队列包含指定的元素，则返回 true 。
      E element()
      检索但不删除此双端队列表示的队列的头部。
      void forEach​(Consumer<? super E> action)
      对 Iterable每个元素执行给定操作，直到处理 Iterable所有元素或操作引发异常。
      E getFirst()
      检索但不删除此双端队列的第一个元素。
      E getLast()
      检索但不删除此双端队列的最后一个元素。
      boolean isEmpty()
      如果此双端队列不包含任何元素，则返回 true 。
      Iterator<E> iterator()
      返回此双端队列中元素的迭代器。
      boolean offer​(E e)
      在此双端队列的末尾插入指定的元素。
      boolean offerFirst​(E e)
      在此双端队列的前面插入指定的元素。
      boolean offerLast​(E e)
      在此双端队列的末尾插入指定的元素。
      E peek()
      检索但不删除此双端队列表示的队列的头部，如果此双端队列为空，则返回 null 。
      E poll()
      检索并删除此双端队列表示的队列的头部（换句话说，此双端队列的第一个元素），如果此双端队列为空，则返回 null 。
      E pop()
      从此双端队列表示的堆栈中弹出一个元素。
      void push​(E e)
      将元素推送到此双端队列表示的堆栈上。
      E remove()
      检索并删除此双端队列表示的队列的头部。
      boolean remove​(Object o)
      从此双端队列中删除指定元素的单个实例。
      boolean removeAll​(Collection<?> c)
      删除此集合的所有元素，这些元素也包含在指定的集合中（可选操作）。
      E removeFirst()
      检索并删除此双端队列的第一个元素。
      boolean removeFirstOccurrence​(Object o)
      删除此双端队列中第一次出现的指定元素（从头到尾遍历双端队列时）。
      boolean removeIf​(Predicate<? super E> filter)
      删除此集合中满足给定谓词的所有元素。
      E removeLast()
      检索并删除此双端队列的最后一个元素。
      boolean removeLastOccurrence​(Object o)
      删除此双端队列中最后一次出现的指定元素（从头到尾遍历双端队列时）。
      boolean retainAll​(Collection<?> c)
      仅保留此集合中包含在指定集合中的元素（可选操作）。
      int size()
      返回此双端队列中的元素数。
      Spliterator<E> spliterator()
      在此双端队列中的元素上创建late-binding和失败快速 Spliterator 。
      Object[] toArray()
      以适当的顺序（从第一个元素到最后一个元素）返回一个包含此双端队列中所有元素的数组。
      <T> T[] toArray​(T[] a)
      以适当的顺序（从第一个元素到最后一个元素）返回一个包含此双端队列中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。

    • 构造方法详细信息

      • ArrayDeque

        public ArrayDeque()
        构造一个空数组deque，其初始容量足以容纳16个元素。

      • ArrayDeque

        public ArrayDeque​(int numElements)
        构造一个空数组deque，其初始容量足以容纳指定数量的元素。
        参数
        numElements - 双端队列初始容量的下限

      • ArrayDeque

        public ArrayDeque​(Collection<? extends E> c)
        按照集合的迭代器返回的顺序构造一个包含指定集合元素的双端队列。 （集合的迭代器返回的第一个元素成为第一个元素，或者是双端队列的前面 。）
        参数
        c - c元素放入双端队列的集合
        异常
        NullPointerException - 如果指定的集合为null

    • 方法详细信息

      • addFirst

        public void addFirst​(E e)
        在此双端队列的前面插入指定的元素。
        Specified by:
        addFirst in interface Deque<E>
        参数
        e - 要添加的元素
        异常
        NullPointerException - 如果指定的元素为null

      • addLast

        public void addLast​(E e)
        在此双端队列的末尾插入指定的元素。

        此方法相当于add(E) 。

        Specified by:
        addLast ，界面 Deque<E>
        参数
        e - 要添加的元素
        异常
        NullPointerException - 如果指定的元素为null

      • offerFirst

        public boolean offerFirst​(E e)
        在此双端队列的前面插入指定的元素。
        Specified by:
        offerFirst在界面 Deque<E>
        参数
        e - 要添加的元素
        结果
        true （由 Deque.offerFirst(E)指定）
        异常
        NullPointerException - 如果指定的元素为null

      • offerLast

        public boolean offerLast​(E e)
        在此双端队列的末尾插入指定的元素。
        Specified by:
        offerLast in界面 Deque<E>
        参数
        e - 要添加的元素
        结果
        true （由 Deque.offerLast(E)指定）
        异常
        NullPointerException - 如果指定的元素为null

      • removeFirst

        public E removeFirst()
        从界面复制的说明： Deque
        检索并删除此双端队列的第一个元素。 此方法与pollFirst的不同之处仅在于，如果此双端队列为空，则会抛出异常。
        Specified by:
        removeFirst在界面 Deque<E>
        结果
        这个双端队长
        异常
        NoSuchElementException - 如果此双端队列是空的

      • removeLast

        public E removeLast()
        从界面复制的说明： Deque
        检索并删除此双端队列的最后一个元素。 此方法与pollLast的不同之处仅在于，如果此双端队列为空，则会抛出异常。
        Specified by:
        removeLast in interface Deque<E>
        结果
        这个双端队员的尾巴
        异常
        NoSuchElementException - 如果此双端队列为空

      • getFirst

        public E getFirst()
        从界面复制的说明： Deque
        检索但不删除此双端队列的第一个元素。 此方法与peekFirst的不同之处仅在于，如果此双端队列为空，则会抛出异常。
        Specified by:
        getFirst ，接口 Deque<E>
        结果
        这个双端队长
        异常
        NoSuchElementException - 如果此双端队列是空的

      • getLast

        public E getLast()
        从界面复制的说明： Deque
        检索但不删除此双端队列的最后一个元素。 此方法与peekLast的不同之处仅在于，如果此双端队列为空，则会抛出异常。
        Specified by:
        getLast在界面 Deque<E>
        结果
        这个双端队员的尾巴
        异常
        NoSuchElementException - 如果此双端队列是空的

      • removeFirstOccurrence

        public boolean removeFirstOccurrence​(Object o)
        删除此双端队列中第一次出现的指定元素（从头到尾遍历双端队列时）。 如果双端队列不包含该元素，则不会更改。 更正式地，删除第一个元素e ，使得o.equals(e) （如果存在这样的元素）。 如果此双端队列包含指定的元素，则返回true （或等效地，如果此双端队列因调用而更改）。
        Specified by:
        removeFirstOccurrence在界面 Deque<E>
        参数
        o - 要从此双端队列中删除的元素（如果存在）
        结果
        true如果deque包含指定的元素

      • removeLastOccurrence

        public boolean removeLastOccurrence​(Object o)
        删除此双端队列中最后一次出现的指定元素（从头到尾遍历双端队列时）。 如果双端队列不包含该元素，则不会更改。 更正式地，删除最后一个元素e ，使o.equals(e) （如果存在这样的元素）。 如果此双端队列包含指定的元素，则返回true （或等效地，如果此双端队列因调用而更改）。
        Specified by:
        removeLastOccurrence in interface Deque<E>
        参数
        o - 要从此双端队列中删除的元素（如果存在）
        结果
        true如果deque包含指定的元素

      • remove

        public E remove()
        检索并删除此双端队列表示的队列的头部。 此方法与poll()的不同之处仅在于，如果此双端队列为空，则会抛出异常。

        此方法相当于removeFirst() 。

        Specified by:
        remove在界面 Deque<E>
        Specified by:
        remove在界面 Queue<E>
        结果
        这个双端队列所代表的队列的头部
        异常
        NoSuchElementException - 如果此双端队列是空的

      • poll

        public E poll()
        检索并移除此双端队列表示的队列的头部（换句话说，此双端队列的第一个元素），如果此双端队列为空，则返回null 。

        此方法相当于Deque.pollFirst() 。

        Specified by:
        poll in interface Deque<E>
        Specified by:
        poll在界面 Queue<E>
        结果
        此双端队列表示队列的头部，如果此双端队列为空， null

      • element

        public E element()
        检索但不删除此双端队列表示的队列的头部。 此方法与peek的区别仅在于，如果此双端队列为空，则抛出异常。

        此方法相当于getFirst() 。

        Specified by:
        element in interface Deque<E>
        Specified by:
        element在界面 Queue<E>
        结果
        这个双端队列所代表的队列的头部
        异常
        NoSuchElementException - 如果此双端队列是空的

      • peek

        public E peek()
        检索但不删除此双端队列表示的队列的头部，如果此双端队列为空，则返回null 。

        此方法相当于Deque.peekFirst() 。

        Specified by:
        peek在界面 Deque<E>
        Specified by:
        peek在界面 Queue<E>
        结果
        此双端队列表示队列的头部，如果此双端队列为空， null

      • push

        public void push​(E e)
        将元素推送到此双端队列表示的堆栈上。 换句话说，将元素插入此双端队列的前面。

        此方法相当于addFirst(E) 。

        Specified by:
        push在界面 Deque<E>
        参数
        e - 要推送的元素
        异常
        NullPointerException - 如果指定的元素为null

      • pop

        public E pop()
        从此双端队列表示的堆栈中弹出一个元素。 换句话说，删除并返回此双端队列的第一个元素。

        此方法相当于removeFirst() 。

        Specified by:
        pop in interface Deque<E>
        结果
        此双端队列前面的元素（此双端队列表示的堆栈顶部）
        异常
        NoSuchElementException - 如果此双端队列是空的

      • size

        public int size()
        返回此双端队列中的元素数。
        Specified by:
        size ，界面 Collection<E>
        Specified by:
        size in interface Deque<E>
        结果
        此双端队列中的元素数量

      • isEmpty

        public boolean isEmpty()
        如果此双端队列不包含任何元素，则返回 true 。
        Specified by:
        isEmpty ，界面 Collection<E>
        重写：
        isEmpty在课程 AbstractCollection<E>
        结果
        true如果此双端队列不包含任何元素

      • forEach

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

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

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

      • removeIf

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

      • contains

        public boolean contains​(Object o)
        如果此双端队列包含指定的元素，则返回true 。 更正式的，返回true当且仅当此双端队列包含至少一个元素e如o.equals(e) 。
        Specified by:
        contains在界面 Collection<E>
        Specified by:
        contains在界面 Deque<E>
        重写：
        contains在课程 AbstractCollection<E>
        参数
        o - 要在此双端队列中检查包含的对象
        结果
        true如果此双端队列包含指定的元素

      • remove

        public boolean remove​(Object o)
        从此双端队列中删除指定元素的单个实例。 如果双端队列不包含该元素，则不会更改。 更正式地，删除第一个元素e ，使o.equals(e) （如果存在这样的元素）。 如果此双端队列包含指定元素，则返回true （或等效地，如果此双端队列因调用而更改）。

        此方法相当于removeFirstOccurrence(Object) 。

        Specified by:
        remove在界面 Collection<E>
        Specified by:
        remove in interface Deque<E>
        重写：
        remove在课程 AbstractCollection<E>
        参数
        o - 要从此双端队列中删除的元素（如果存在）
        结果
        true如果此双端队列包含指定的元素

      • clear

        public void clear()
        从此双端队列中删除所有元素。 此调用返回后，双端队列将为空。
        Specified by:
        clear接口 Collection<E>
        重写：
        clear在课程 AbstractCollection<E>

      • toArray

        public Object[] toArray()
        以适当的顺序（从第一个元素到最后一个元素）返回一个包含此双端队列中所有元素的数组。

        返回的数组将是“安全的”，因为此双端队列不会保留对它的引用。 （换句话说，此方法必须分配一个新数组）。 因此调用者可以自由修改返回的数组。

        此方法充当基于阵列和基于集合的API之间的桥梁。

        Specified by:
        toArray接口 Collection<E>
        重写：
        toArray在类 AbstractCollection<E>
        结果
        包含此双端队列中所有元素的数组

      • toArray

        public <T> T[] toArray​(T[] a)
        以适当的顺序（从第一个元素到最后一个元素）返回一个包含此双端队列中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。 如果deque适合指定的数组，则返回其中。 否则，将使用指定数组的运行时类型和此双端队列的大小分配新数组。

        如果此双端队列适合指定的数组，并且有空余空间（即，数组的元素数多于此双端队列），紧接在双端队列结束后的数组中的元素将设置为null 。

        与toArray()方法一样，此方法充当基于阵列和基于集合的API之间的桥梁。 此外，该方法允许精确控制输出阵列的运行时类型，并且在某些情况下可以用于节省分配成本。

        假设x是一个已知只包含字符串的双端队列。 以下代码可用于将deque转储到新分配的String数组中： 

          String[] y = x.toArray(new String[0]);
        请注意， toArray(new Object[0])功能与toArray()相同。
        Specified by:
        toArray在界面 Collection<E>
        重写：
        toArray在课程 AbstractCollection<E>
        参数类型
        T - 要包含集合的数组的组件类型
        参数
        a - 如果足够大，则存储双端队列元素的数组; 否则，为此目的分配相同运行时类型的新数组
        结果
        包含此双端队列中所有元素的数组
        异常
        ArrayStoreException - 如果指定数组的运行时类型不是此双端队列中每个元素的运行时类型的超类型
        NullPointerException - 如果指定的数组为null

      • clone

        public ArrayDeque<E> clone()
        返回此双端队列的副本。
        重写：
        clone在课程 Object
        结果
        这个双端队列的副本
        另请参见：
        Cloneable