Module  java.base
软件包  java.util.concurrent

Class LinkedBlockingDeque<E>

    • 方法摘要

      所有方法  接口方法  具体的方法 
      Modifier and Type 方法 描述
      boolean add​(E e)
      在此deque的末尾插入指定的元素，除非它会违反容量限制。
      boolean addAll​(Collection<? extends E> c)
      按照指定集合的迭代器返回的顺序将指定集合中的所有元素追加到该deque的末尾。
      void addFirst​(E e)
      如果可以立即在不违反容量限制的情况下将指定的元素插入到此deque的前面，如果当前没有可用的空间，则抛出一个 IllegalStateException 。
      void addLast​(E e)
      如果可以立即在不违反容量限制的情况下将指定的元素插入到此deque的末尾，如果当前没有可用空间，则抛出 IllegalStateException 。
      void clear​()
      从这个deque原子地删除所有的元素。
      boolean contains​(Object o)
      如果此deque包含指定的元素，则返回 true 。
      Iterator<E> descendingIterator​()
      以相反的顺序返回此deque中的元素的迭代器。
      int drainTo​(Collection<? super E> c)
      从该队列中删除所有可用的元素，并将它们添加到给定的集合中。
      int drainTo​(Collection<? super E> c, int maxElements)
      最多从该队列中删除给定数量的可用元素，并将它们添加到给定的集合中。
      E element​()
      检索，但不删除，由这个deque表示的队列的头。
      void forEach​(Consumer<? super E> action)
      对 Iterable每个元素执行给定的操作，直到所有元素都被处理或者动作引发异常。
      E getFirst​()
      检索，但不删除，这个deque的第一个元素。
      E getLast​()
      检索，但不删除，这个deque的最后一个元素。
      Iterator<E> iterator​()
      以正确的顺序返回此deque中的元素的迭代器。
      boolean offer​(E e)
      将指定的元素插入此双端队列表示的队列中（换句话说，在此双端队列的尾部），如果它是立即可行且不会违反容量限制，返回 true在成功和 false ，如果当前没有空间可用。
      boolean offer​(E e, long timeout, TimeUnit unit)
      将指定的元素插入由此deque表示的队列中（换句话说，在该deque的尾部），等待指定的等待时间（如果需要空间可用）。
      boolean offerFirst​(E e)
      插入此双端队列的前面，如果它是立即可行且不会违反容量限制，返回指定的元素 true在成功 false如果当前没有空间可用。
      boolean offerFirst​(E e, long timeout, TimeUnit unit)
      在此deque的前面插入指定的元素，等待指定的等待时间（如果需要空间可用）。
      boolean offerLast​(E e)
      插入此双端队列的末尾，如果它是立即可行且不会违反容量限制，返回指定的元素 true在成功 false如果当前没有空间可用。
      boolean offerLast​(E e, long timeout, TimeUnit unit)
      在此deque的末尾插入指定的元素，如果需要空间可用，等待指定的等待时间。
      E peek​()
      检索但不删除由此deque表示的队列的头部（换句话说，此deque的第一个元素），如果此deque为空，则返回 null 。
      E peekFirst​()
      检索，但不删除，此deque的第一个元素，或返回 null如果这个deque是空的。
      E peekLast​()
      检索但不删除此deque的最后一个元素，如果此deque为空，则返回 null 。
      E poll​()
      检索并删除由此deque表示的队列的头（换句话说，该deque的第一个元素），或者如果此deque为空，则返回 null 。
      E poll​(long timeout, TimeUnit unit)
      检索并删除由此deque（换句话说，该deque的第一个元素）表示的队列的头部，等待到指定的等待时间（如有必要）使元素变为可用。
      E pollFirst​()
      检索并删除此deque的第一个元素，如果此deque为空，则返回 null 。
      E pollFirst​(long timeout, TimeUnit unit)
      检索并删除此deque的第一个元素，等待到指定的等待时间（如有必要）使元素变为可用。
      E pollLast​()
      检索并删除此deque的最后一个元素，如果此deque为空，则返回 null 。
      E pollLast​(long timeout, TimeUnit unit)
      检索并删除此deque的最后一个元素，等待到指定的等待时间，如果需要，元素可用。
      E pop​()
      从这个deque表示的堆栈中弹出一个元素。
      void push​(E e)
      将元素推送到由此deque表示的堆栈（换句话说，在该deque的头部），如果可以立即执行，而不违反容量限制，则抛出一个 IllegalStateException如果当前没有可用的空间）。
      void put​(E e)
      将指定的元素插入由此deque表示的队列（换句话说，在该deque的尾部），等待空格变为可用时。
      void putFirst​(E e)
      在此deque的前面插入指定的元素，如有必要，等待空格变为可用。
      void putLast​(E e)
      在此deque的末尾插入指定的元素，如有必要，等待空格变为可用。
      int remainingCapacity​()
      返回此deque可以理想地（在没有内存或资源限制）的情况下接受而不阻止的附加元素数。
      E remove​()
      检索并删除由此deque表示的队列的头部。
      boolean remove​(Object o)
      从此deque中删除指定元素的第一个出现。
      boolean removeAll​(Collection<?> c)
      删除指定集合中包含的所有此集合的元素（可选操作）。
      E removeFirst​()
      检索并删除此deque的第一个元素。
      boolean removeFirstOccurrence​(Object o)
      从此deque中删除指定元素的第一个出现。
      boolean removeIf​(Predicate<? super E> filter)
      删除满足给定谓词的此集合的所有元素。
      E removeLast​()
      检索并删除此deque的最后一个元素。
      boolean removeLastOccurrence​(Object o)
      从此deque中删除指定元素的最后一次出现。
      boolean retainAll​(Collection<?> c)
      仅保留此集合中包含在指定集合中的元素（可选操作）。
      int size​()
      返回此deque中的元素数。
      Spliterator<E> spliterator​()
      在此deque中的元素上返回一个Spliterator 。
      E take​()
      检索并删除由此deque（换句话说，该deque的第一个元素）表示的队列的头部，如果需要，等待，直到元素可用。
      E takeFirst​()
      检索并删除此deque的第一个元素，如有必要等待，直到元素可用。
      E takeLast​()
      检索并删除此deque的最后一个元素，如有必要等待，直到元素可用。
      Object[] toArray​()
      以适当的顺序（从第一个到最后一个元素）返回一个包含此deque中所有元素的数组。
      <T> T[] toArray​(T[] a)
      以适当的顺序返回一个包含此deque中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。
      String toString​()
      返回此集合的字符串表示形式。

    • 构造方法详细信息

      • LinkedBlockingDeque

        public LinkedBlockingDeque​()
        创建 LinkedBlockingDeque ，容量为 Integer.MAX_VALUE 。

      • LinkedBlockingDeque

        public LinkedBlockingDeque​(int capacity)
        创建一个给定（固定）容量的 LinkedBlockingDeque 。
        参数
        capacity - 这个deque的容量
        异常
        IllegalArgumentException - 如果 capacity小于1

      • LinkedBlockingDeque

        public LinkedBlockingDeque​(Collection<? extends E> c)
        创建一个 LinkedBlockingDeque ，容量为 Integer.MAX_VALUE ，最初包含给定集合的元素，以集合的迭代器的遍历顺序添加。
        参数
        c - 最初包含的元素的集合
        异常
        NullPointerException - 如果指定的集合或其任何元素为空

    • 方法详细信息

      • addFirst

        public void addFirst​(E e)
        描述从接口BlockingDeque复制
        如果可以在不违反容量限制的情况下立即将该指定元素插入到此deque的前面，如果当前没有可用的空间，则抛出一个IllegalStateException 。 当使用容量限制的deque时，通常最好使用offerFirst 。
        Specified by:
        addFirst在接口 BlockingDeque<E>
        Specified by:
        addFirst在接口 Deque<E>
        参数
        e - 要添加的元素
        异常
        IllegalStateException - 如果这个deque是满的
        NullPointerException - 如果指定的元素为空

      • addLast

        public void addLast​(E e)
        说明从接口BlockingDeque复制
        如果可以立即在不违反容量限制的情况下将指定的元素插入到此deque的末尾，则抛出一个IllegalStateException如果当前没有可用空间）。 当使用容量限制的deque时，通常最好使用offerLast 。
        Specified by:
        addLast在接口 BlockingDeque<E>
        Specified by:
        addLast在接口 Deque<E>
        参数
        e - 要添加的元素
        异常
        IllegalStateException - 如果这个deque是满的
        NullPointerException - 如果指定的元素为空

      • offerFirst

        public boolean offerFirst​(E e)
        说明从接口BlockingDeque复制
        插入此双端队列的前面，如果它是立即可行且不会违反容量限制，返回指定的元素true在成功false如果当前没有空间可用。 当使用容量限制的deque时，这种方法通常比addFirst方法更为方便 ，只能通过抛出异常来插入元素。
        Specified by:
        offerFirst在接口 BlockingDeque<E>
        Specified by:
        offerFirst在接口 Deque<E>
        参数
        e - 要添加的元素
        结果
        true如果元素被添加到此deque，否则为 false
        异常
        NullPointerException - 如果指定的元素为空

      • offerLast

        public boolean offerLast​(E e)
        说明从接口BlockingDeque复制
        插入此双端队列的末尾，如果它是立即可行且不会违反容量限制，返回指定的元素true在成功false如果当前没有空间可用。 当使用容量受限制的deque时，该方法通常比addLast方法更为方便 ，只能通过抛出异常来插入元素。
        Specified by:
        offerLast在接口 BlockingDeque<E>
        Specified by:
        offerLast在接口 Deque<E>
        参数
        e - 要添加的元素
        结果
        true如果元素被添加到此deque，否则为 false
        异常
        NullPointerException - 如果指定的元素为空

      • offerFirst

        public boolean offerFirst​(E e,
                          long timeout,
                          TimeUnit unit)
                   throws InterruptedException
        说明从界面： BlockingDeque复制
        在此deque的前面插入指定的元素，等待指定的等待时间（如果需要空间可用）。
        Specified by:
        offerFirst在接口 BlockingDeque<E>
        参数
        e - 要添加的元素
        timeout - 放弃之前等待多长时间，以 unit为单位
        unit - a TimeUnit确定如何解释 timeout参数
        结果
        true如果成功，或 false如果在空间可用之前经过了指定的等待时间
        异常
        NullPointerException - 如果指定的元素为空
        InterruptedException - 如果等待中断

      • offerLast

        public boolean offerLast​(E e,
                         long timeout,
                         TimeUnit unit)
                  throws InterruptedException
        说明从接口BlockingDeque复制
        在此deque的末尾插入指定的元素，如果需要空间可用，等待指定的等待时间。
        Specified by:
        offerLast在接口 BlockingDeque<E>
        参数
        e - 要添加的元素
        timeout - 放弃之前等待多长时间，以 unit为单位
        unit - a TimeUnit确定如何解释 timeout参数
        结果
        true如果成功，或 false如果在空间可用之前经过指定的等待时间
        异常
        NullPointerException - 如果指定的元素为空
        InterruptedException - 如果在等待时中断

      • removeFirst

        public E removeFirst​()
        说明从界面： Deque复制
        检索并删除此deque的第一个元素。 此方法与pollFirst的不同之处在于，如果此deque为空，它将抛出异常。
        Specified by:
        removeFirst在接口 Deque<E>
        结果
        这个德克的头
        异常
        NoSuchElementException - 如果这个deque是空的

      • removeLast

        public E removeLast​()
        说明从界面复制： Deque
        检索并删除此deque的最后一个元素。 此方法与pollLast不同之处在于，如果此deque为空，它将抛出异常。
        Specified by:
        removeLast接口 Deque<E>
        结果
        这个德克的尾巴
        异常
        NoSuchElementException - 如果这个deque是空的

      • pollFirst

        public E pollFirst​()
        说明从接口Deque复制
        检索并删除此deque的第一个元素，如果此deque为空，则返回 null 。
        Specified by:
        pollFirst接口 Deque<E>
        结果
        这个deque的头，或 null如果这个deque是空的

      • pollLast

        public E pollLast​()
        描述从接口Deque复制
        检索并删除此deque的最后一个元素，如果此deque为空，则返回 null 。
        Specified by:
        pollLast在接口 Deque<E>
        结果
        这个deque的尾巴，或 null如果这个deque是空的

      • pollFirst

        public E pollFirst​(long timeout,
                   TimeUnit unit)
            throws InterruptedException
        说明从界面： BlockingDeque复制
        检索并删除此deque的第一个元素，等待到指定的等待时间（如有必要）使元素变为可用。
        Specified by:
        pollFirst在接口 BlockingDeque<E>
        参数
        timeout - 放弃之前等待多久，以 unit为单位
        unit - a TimeUnit确定如何解释 timeout参数
        结果
        如果在元素可用之前经过了指定的等待时间，则此deque的头部，或 null
        异常
        InterruptedException - 如果在等待时中断

      • pollLast

        public E pollLast​(long timeout,
                  TimeUnit unit)
           throws InterruptedException
        描述从接口BlockingDeque复制
        检索并删除此deque的最后一个元素，等待到指定的等待时间，如果需要，元素可用。
        Specified by:
        pollLast在接口 BlockingDeque<E>
        参数
        timeout - 放弃之前等待多久，以 unit为单位
        unit - a TimeUnit确定如何解释 timeout参数
        结果
        如果在元素可用之前经过了指定的等待时间，则此deque的尾部，或 null
        异常
        InterruptedException - 如果在等待时中断

      • getFirst

        public E getFirst​()
        说明从界面复制： Deque
        检索，但不删除，这个deque的第一个元素。 此方法与peekFirst不同之处在于，如果此deque为空，它将抛出异常。
        Specified by:
        getFirst在接口 Deque<E>
        结果
        这个德克的头
        异常
        NoSuchElementException - 如果这个deque是空的

      • getLast

        public E getLast​()
        说明从界面： Deque复制
        检索，但不删除，这个deque的最后一个元素。 此方法与peekLast不同之处在于，如果此deque为空，它将抛出异常。
        Specified by:
        getLast在接口 Deque<E>
        结果
        这个德克的尾巴
        异常
        NoSuchElementException - 如果这个deque是空的

      • peekFirst

        public E peekFirst​()
        描述从接口Deque复制
        检索但不删除此deque的第一个元素，如果此deque为空，则返回 null 。
        Specified by:
        peekFirst在接口 Deque<E>
        结果
        这个deque的头，或 null如果这个deque是空的

      • peekLast

        public E peekLast​()
        说明从界面Deque复制
        检索但不删除此deque的最后一个元素，如果此deque为空，则返回 null 。
        Specified by:
        peekLast在接口 Deque<E>
        结果
        这个deque的尾巴，或 null如果这个deque是空的

      • removeFirstOccurrence

        public boolean removeFirstOccurrence​(Object o)
        描述从接口BlockingDeque复制
        从此deque中删除指定元素的第一个出现。 如果deque不包含元素，则它不变。 更正式地，删除第一元素e使得o.equals(e) （如果这样的元素存在）。 如果此deque包含指定的元素（或等效地，如果此deque由于调用而更改），则返回true 。
        Specified by:
        removeFirstOccurrence在接口 BlockingDeque<E>
        Specified by:
        removeFirstOccurrence在接口 Deque<E>
        参数
        o - 要从此deque移除的元素（如果存在）
        结果
        true如果一个元素被删除作为这个调用的结果

      • removeLastOccurrence

        public boolean removeLastOccurrence​(Object o)
        说明从界面BlockingDeque复制
        从此deque中删除指定元素的最后一次出现。 如果deque不包含元素，则它不变。 更正式地，删除最后一个元素e ，使得o.equals(e) （如果这样的元素存在）。 如果此deque包含指定的元素（或等效地，如果此deque由于调用而更改），则返回true 。
        Specified by:
        removeLastOccurrence在接口 BlockingDeque<E>
        Specified by:
        removeLastOccurrence在接口 Deque<E>
        参数
        o - 要从此deque移除的元素（如果存在）
        结果
        true如果一个元素被删除作为这个调用的结果

      • offer

        public boolean offer​(E e)
        说明从界面BlockingDeque复制
        将指定的元素插入此双端队列表示的队列中（换句话说，在此双端队列的尾部），如果它是立即可行且不会违反容量限制，返回true在成功和false ，如果当前没有空间可用。 当使用容量限制的deque时，这种方法通常比BlockingDeque.add(E)方法更为方便 ，只能通过抛出异常来插入元素。

        此方法相当于offerLast 。

        Specified by:
        offer在接口 BlockingDeque<E>
        Specified by:
        offer在接口 BlockingQueue<E>
        Specified by:
        offer在接口 Deque<E>
        Specified by:
        offer在接口 Queue<E>
        参数
        e - 要添加的元素
        结果
        true如果元素被添加到此队列，否则为 false
        异常
        NullPointerException - 如果指定的元素为空

      • offer

        public boolean offer​(E e,
                     long timeout,
                     TimeUnit unit)
              throws InterruptedException
        描述从接口BlockingDeque复制
        将指定的元素插入由此deque表示的队列中（换句话说，在该deque的尾部），等待指定的等待时间（如果需要空间可用）。

        此方法相当于offerLast 。

        Specified by:
        offer在接口 BlockingDeque<E>
        Specified by:
        offer在接口 BlockingQueue<E>
        参数
        e - 要添加的元素
        timeout - 放弃之前等待多长时间，以 unit为单位
        unit - a TimeUnit确定如何解释 timeout参数
        结果
        true如果元素被添加到此deque，否则为 false
        异常
        NullPointerException - 如果指定的元素为空
        InterruptedException - 如果在等待时中断

      • poll

        public E poll​()
        说明从界面BlockingDeque复制
        检索并删除由此deque（换句话说，此deque的第一个元素）表示的队列的头部，如果此deque为空，则返回null 。

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

        Specified by:
        poll在接口 BlockingDeque<E>
        Specified by:
        poll在接口 Deque<E>
        Specified by:
        poll在接口 Queue<E>
        结果
        这个deque的头，或 null如果这个deque是空的

      • poll

        public E poll​(long timeout,
              TimeUnit unit)
       throws InterruptedException
        说明从界面： BlockingDeque复制
        检索并删除由此deque（换句话说，该deque的第一个元素）表示的队列的头部，等待到指定的等待时间（如有必要）使元素变为可用。

        此方法相当于pollFirst 。

        Specified by:
        poll在接口 BlockingDeque<E>
        Specified by:
        poll在接口 BlockingQueue<E>
        参数
        timeout - 放弃等待多久，单位为 unit
        unit - a TimeUnit确定如何解释 timeout参数
        结果
        如果在元素可用之前经过了指定的等待时间，那么这个deque的头，或者是 null
        异常
        InterruptedException - 如果在等待时中断

      • peek

        public E peek​()
        说明从接口BlockingDeque复制
        检索但不删除由此deque表示的队列的头部（换句话说，该deque的第一个元素），如果此deque为空，则返回null 。

        此方法相当于peekFirst 。

        Specified by:
        peek在接口 BlockingDeque<E>
        Specified by:
        peek在接口 Deque<E>
        Specified by:
        peek在接口 Queue<E>
        结果
        这个deque的头，或 null如果这个deque是空的

      • remainingCapacity

        public int remainingCapacity​()
        返回此deque可以理想地（在没有内存或资源限制）的情况下接受而不阻止的附加元素数。 这总是等于这个deque的初始容量，而不是这个deque的当前size 。

        请注意，您不能总是通过检查remainingCapacity来确定插入元素的尝试是否成功，因为可能是另一个线程即将插入或删除元素的情况。

        Specified by:
        remainingCapacity在接口 BlockingQueue<E>
        结果
        剩余容量

      • drainTo

        public int drainTo​(Collection<? super E> c)
        说明从界面BlockingQueue复制
        从该队列中删除所有可用的元素，并将它们添加到给定的集合中。 此操作可能比重复轮询此队列更有效。 尝试向集合c添加元素时遇到的失败可能导致在抛出关联的异常时，元素既不在两个集合中，也可能不是两个集合。 尝试将排队排队自身会导致IllegalArgumentException 。 此外，如果在操作进行中修改了指定的集合，则此操作的行为是未定义的。
        Specified by:
        drainTo在接口 BlockingQueue<E>
        参数
        c - 将元素传输到的集合
        结果
        转移的元素数量
        异常
        UnsupportedOperationException - 如果指定集合不支持元素的添加
        ClassCastException - 如果此队列的元素的类阻止将其添加到指定的集合
        NullPointerException - 如果指定的集合为空
        IllegalArgumentException - 如果指定的集合是此队列，或该队列的元素的某些属性会阻止将其添加到指定的集合

      • drainTo

        public int drainTo​(Collection<? super E> c,
                   int maxElements)
        说明从界面BlockingQueue复制
        最多从该队列中删除给定数量的可用元素，并将它们添加到给定的集合中。 尝试向集合c添加元素时遇到的失败可能会导致元素在抛出关联的异常时既不在两个集合中，也可能不是两个集合。 尝试将排队排队自身会导致IllegalArgumentException 。 此外，如果在操作进行中修改了指定的集合，则此操作的行为是未定义的。
        Specified by:
        drainTo在接口 BlockingQueue<E>
        参数
        c - 将元素传输到的集合
        maxElements - 要传输的元素的最大数量
        结果
        转移的元素数量
        异常
        UnsupportedOperationException - 如果指定的集合不支持添加元素
        ClassCastException - 如果此队列的元素的类阻止将其添加到指定的集合
        NullPointerException - 如果指定的集合为空
        IllegalArgumentException - 如果指定的集合是此队列，或此队列的某个元素的某些属性会阻止将其添加到指定的集合

      • pop

        public E pop​()
        说明从界面： Deque复制
        从这个deque表示的堆栈中弹出一个元素。 换句话说，删除并返回此deque的第一个元素。

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

        Specified by:
        pop在接口 Deque<E>
        结果
        这个deque前面的元素（它是由这个deque表示的堆栈的顶部）
        异常
        NoSuchElementException - 如果这个deque是空的

      • remove

        public boolean remove​(Object o)
        从此deque中删除指定元素的第一个出现。 如果deque不包含元素，则它不变。 更正式地，删除第一元素e使得o.equals(e) （如果这样的元素存在）。 如果此deque包含指定的元素（或等效地，如果此deque由于调用而更改），则返回true 。

        此方法相当于removeFirstOccurrence 。

        Specified by:
        remove在接口 BlockingDeque<E>
        Specified by:
        remove在接口 BlockingQueue<E>
        Specified by:
        remove在接口 Collection<E>
        Specified by:
        remove在接口 Deque<E>
        重写：
        remove在类 AbstractCollection<E>
        参数
        o - 要从此deque中删除的元素（如果存在）
        结果
        true如果这个deque因呼叫而改变了

      • toArray

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

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

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

        Specified by:
        toArray在接口 Collection<E>
        重写：
        toArray在 AbstractCollection<E>
        结果
        一个包含此deque中所有元素的数组

      • toArray

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

        如果这个deque适合指定的数组，有空余的空间（即数组的元素比这个deque更多），紧接在deque结束之后的数组中的元素设置为null 。

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

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

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

      • toString

        public String toString​()
        描述从类别复制： AbstractCollection
        返回此集合的字符串表示形式。 字符串表示由集合的元素的列表按照它们的迭代器返回的顺序包含在方括号（ "[]" ）中。 相邻元素由字符", " （逗号和空格）分隔。 元素将转换为字符串，如String.valueOf(Object) 。
        重写：
        toString在类 AbstractCollection<E>
        结果
        此集合的字符串表示形式

      • clear

        public void clear​()
        从这个deque原子地删除所有的元素。 此呼叫返回后，deque将为空。
        Specified by:
        clear在接口 Collection<E>
        重写：
        clear在 AbstractQueue<E>

      • descendingIterator

        public Iterator<E> descendingIterator​()
        以相反的顺序返回此deque中的元素的迭代器。 元素将从最后（尾）到第一（头）的顺序返回。

        返回的迭代器是weakly consistent 。

        Specified by:
        descendingIterator在接口 Deque<E>
        结果
        在这个deque中的元素的迭代器以相反的顺序

      • forEach

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

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

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

      • removeIf

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