模块  java.base
软件包  java.util.concurrent

Class LinkedBlockingDeque<E>

    • 方法摘要

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

    • 构造方法详细信息

      • LinkedBlockingDeque

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

      • LinkedBlockingDeque

        public LinkedBlockingDeque​(int capacity)
        创建具有给定（固定）容量的 LinkedBlockingDeque 。
        参数
        capacity - 这个双端 capacity的能力
        异常
        IllegalArgumentException - 如果 capacity小于1

      • LinkedBlockingDeque

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

    • 方法详细信息

      • addFirst

        public void addFirst​(E e)
        从界面复制的说明： BlockingDeque
        如果可以在不违反容量限制的情况下立即插入指定元素，则在此双端队列的前面插入指定元素，如果当前没有可用空间，则抛出IllegalStateException 。 当使用容量限制的双端队列时，通常优选使用offerFirst 。
        Specified by:
        addFirst在界面 BlockingDeque<E>
        Specified by:
        addFirst在界面 Deque<E>
        参数
        e - 要添加的元素
        异常
        IllegalStateException - 如果此双端队列已满
        NullPointerException - 如果指定的元素为null

      • addLast

        public void addLast​(E e)
        从界面复制的说明： BlockingDeque
        如果可以在不违反容量限制的情况下立即插入指定元素，则在此双端队列的末尾插入指定元素，如果当前没有可用空间，则抛出IllegalStateException 。 当使用容量限制的双端队列时，通常优选使用offerLast 。
        Specified by:
        addLast在界面 BlockingDeque<E>
        Specified by:
        addLast在界面 Deque<E>
        参数
        e - 要添加的元素
        异常
        IllegalStateException - 如果此双端队列已满
        NullPointerException - 如果指定的元素为null

      • offerFirst

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

      • offerLast

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

      • offerFirst

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

      • offerLast

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

      • removeFirst

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

      • removeLast

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

      • offer

        public boolean offer​(E e)
        从界面复制的说明： BlockingDeque
        将指定的元素插入此双端队列表示的队列中（换句话说，在此双端队列的尾部），如果它是立即可行且不会违反容量限制，返回true在成功和false如果当前没有空间可用。 使用容量限制的双端队列时，此方法通常优于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 - 如果指定的元素为null

      • offer

        public boolean offer​(E e,
                     long timeout,
                     TimeUnit unit)
              throws InterruptedException
        从界面复制的说明： BlockingDeque
        将指定的元素插入此双端队列表示的队列中（换句话说，在此双端队列的尾部），如果需要空间可用，则等待指定的等待时间。

        此方法相当于offerLast 。

        Specified by:
        offer在界面 BlockingDeque<E>
        Specified by:
        offer在界面 BlockingQueue<E>
        参数
        e - 要添加的元素
        timeout - 放弃前等待多长时间，单位为 unit
        unit -一个 TimeUnit确定如何解释 timeout参数
        结果
        true如果元素已添加到此双端队列， false
        异常
        NullPointerException - 如果指定的元素为null
        InterruptedException - 如果在等待时被打断

      • remainingCapacity

        public int remainingCapacity()
        返回此双端队列理想情况下（在没有内存或资源限制的情况下）可以无阻塞地接受的其他元素的数量。 这总是等于此双端队列的初始容量减去此双端队列的当前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 - 如果指定的集合为null
        IllegalArgumentException - 如果指定的集合是此队列，或此队列的某个元素的某些属性阻止将其添加到指定的集合

      • drainTo

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

      • push

        public void push​(E e)
        从界面复制的说明： BlockingDeque
        如果可以在不违反容量限制的情况下立即执行此操作， IllegalStateException到此双端队列表示的堆栈（换句话说，在此双端队列的头部），如果当前没有可用空间则抛出IllegalStateException 。

        此方法相当于addFirst 。

        Specified by:
        push在界面 BlockingDeque<E>
        Specified by:
        push在界面 Deque<E>
        参数
        e - 要推送的元素
        异常
        IllegalStateException - 如果此双端队列已满
        NullPointerException - 如果指定的元素为null

      • pop

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

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

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

      • remove

        public boolean remove​(Object o)
        从此双端队列中删除第一次出现的指定元素。 如果双端队列不包含该元素，则不会更改。 更正式地，删除第一个元素e ，使得o.equals(e) （如果存在这样的元素）。 如果此双端队列包含指定的元素，则返回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 - 要从此双端队列中删除的元素（如果存在）
        结果
        true如果此deque因呼叫而改变

      • size

        public int size()
        返回此双端队列中的元素数。
        Specified by:
        size在界面 BlockingDeque<E>
        Specified by:
        size在界面 Collection<E>
        Specified by:
        size在界面 Deque<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

      • clear

        public void clear()
        原子地从该双端队列中移除所有元素。 此调用返回后，双端队列将为空。
        Specified by:
        clear在界面 Collection<E>
        重写：
        clear类 AbstractQueue<E>

      • descendingIterator

        public Iterator<E> descendingIterator()
        以相反的顺序返回此双端队列中元素的迭代器。 元素将按从最后（尾部）到第一个（头部）的顺序返回。

        返回的迭代器是weakly consistent 。

        Specified by:
        descendingIterator在界面 Deque<E>
        结果
        以相反的顺序在此双端队列中的元素上的迭代器

      • forEach

        public void forEach​(Consumer<? super E> action)
        从界面复制的说明： 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