java.lang.Object
- java.util.AbstractCollection<E>
- - java.util.AbstractQueue<E>
  - - java.util.concurrent.LinkedTransferQueue<E>

参数类型

E - 此队列中保留的元素类型

实现的所有接口

Serializable ， Iterable<E> ， Collection<E> ， BlockingQueue<E> ， TransferQueue<E> ， Queue<E>
```
public class LinkedTransferQueue<E>
extends AbstractQueue<E>
implements TransferQueue<E>, Serializable
```
基于链接节点的无界TransferQueue 。该队列针对任何给定的生产者对元素FIFO（先入先出）进行排序。队列的头部是队列中某个生产者最长时间的元素。队列的尾部是队列中的元素，对于某些生产者来说是最短的时间。
请注意，与大多数集合不同， size方法不是恒定时间操作。由于这些队列的异步性质，确定当前元素数量需要遍历元素，因此如果在遍历期间修改此集合，则可能会报告不准确的结果。

该添加，删除，或检查多个元件批量操作，如AbstractQueue.addAll(java.util.Collection<? extends E>) ， removeIf(java.util.function.Predicate<? super E>)或forEach(java.util.function.Consumer<? super E>)被原子方式执行，不能保证。例如，与addAll操作同时进行的forEach遍历可能只会观察到一些添加的元素。

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

存储器一致性效果：当与其他并发集合，事先将物体放置成在一个线程动作LinkedTransferQueue happen-before到该元素的从访问或移除后续动作LinkedTransferQueue在另一个线程。

此类是Java Collections Framework的成员。

从以下版本开始：

1.7

另请参见：

Serialized Form

构造方法摘要

构造方法
构造器	描述
`LinkedTransferQueue()`	创建一个最初为空的 `LinkedTransferQueue` 。
`LinkedTransferQueue(Collection<? extends E> c)`	创建一个最初包含给定集合元素的 `LinkedTransferQueue` ，以集合迭代器的遍历顺序添加。

方法摘要

所有方法实例方法具体的方法
变量和类型	方法	描述
`boolean`	`add(E e)`	将指定元素插入此队列的尾部。
`boolean`	`contains(Object o)`	如果此队列包含指定的元素，则返回 `true` 。
`int`	`drainTo(Collection<? super E> c)`	从此队列中删除所有可用元素，并将它们添加到给定集合中。
`int`	`drainTo(Collection<? super E> c, int maxElements)`	从该队列中删除最多给定数量的可用元素，并将它们添加到给定集合中。
`void`	`forEach(Consumer<? super E> action)`	对 `Iterable`每个元素执行给定操作，直到处理 `Iterable`所有元素或操作引发异常。
`boolean`	`isEmpty()`	如果此队列不包含任何元素，则返回 `true` 。
`Iterator<E>`	`iterator()`	以适当的顺序返回此队列中元素的迭代器。
`boolean`	`offer(E e)`	将指定元素插入此队列的尾部。
`boolean`	`offer(E e, long timeout, TimeUnit unit)`	将指定元素插入此队列的尾部。
`void`	`put(E e)`	将指定元素插入此队列的尾部。
`int`	`remainingCapacity()`	始终返回 `Integer.MAX_VALUE`因为 `LinkedTransferQueue`不受容量限制。
`boolean`	`remove(Object o)`	从此队列中删除指定元素的单个实例（如果存在）。
`boolean`	`removeAll(Collection<?> c)`	删除此集合的所有元素，这些元素也包含在指定的集合中（可选操作）。
`boolean`	`removeIf(Predicate<? super E> filter)`	删除此集合中满足给定谓词的所有元素。
`boolean`	`retainAll(Collection<?> c)`	仅保留此集合中包含在指定集合中的元素（可选操作）。
`int`	`size()`	返回此队列中的元素数。
`Spliterator<E>`	`spliterator()`	在此队列中的元素上返回`Spliterator` 。
`Object[]`	`toArray()`	以适当的顺序返回包含此队列中所有元素的数组。
`<T> T[]`	`toArray(T[] a)`	以适当的顺序返回包含此队列中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。
`void`	`transfer(E e)`	将元素传输给消费者，在必要时等待。
`boolean`	`tryTransfer(E e)`	如果可能，立即将元素转移给等待的消费者。
`boolean`	`tryTransfer(E e, long timeout, TimeUnit unit)`	如果可以在超时过去之前执行此操作，则将元素传输给使用者。

声明方法的类 java.util.AbstractQueue
addAll, clear, element, remove

声明方法的类 java.util.AbstractCollection
containsAll, toString

声明方法的类 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

声明方法的接口 java.util.concurrent.BlockingQueue
poll, take

声明方法的接口 java.util.Collection
addAll, clear, containsAll, equals, hashCode, parallelStream, stream, toArray

声明方法的接口 java.util.Queue
element, peek, poll, remove

声明方法的接口 java.util.concurrent.TransferQueue
getWaitingConsumerCount, hasWaitingConsumer

- 构造方法详细信息
  - LinkedTransferQueue
```
public LinkedTransferQueue()
```
    创建一个最初为空的 LinkedTransferQueue 。
  - LinkedTransferQueue
```
public LinkedTransferQueue(Collection<? extends E> c)
```
    创建一个最初包含给定集合元素的 LinkedTransferQueue ，以集合迭代器的遍历顺序添加。
    
    参数
    
    c - 最初包含的元素集合
    
    异常
    
    NullPointerException - 如果指定的集合或其任何元素为null
- 方法详细信息
  - toArray
```
public Object[] toArray()
```
    以适当的顺序返回包含此队列中所有元素的数组。
    返回的数组将是“安全的”，因为此队列不会保留对它的引用。（换句话说，此方法必须分配一个新数组）。因此调用者可以自由修改返回的数组。
    
    此方法充当基于阵列和基于集合的API之间的桥梁。
    
    Specified by:
    
    toArray在界面 Collection<E>
    
    重写：
    
    toArray在课程 AbstractCollection<E>
    
    结果
    
    包含此队列中所有元素的数组
  - toArray
```
public <T> T[] toArray(T[] a)
```
    以适当的顺序返回包含此队列中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。如果队列适合指定的数组，则返回其中。否则，将使用指定数组的运行时类型和此队列的大小分配新数组。
    如果此队列适合具有备用空间的指定数组（即，该数组具有比此队列多的元素），则紧跟在队列末尾之后的数组中的元素将设置为null 。
    
    与toArray()方法一样，此方法充当基于数组的API和基于集合的API之间的桥梁。此外，该方法允许精确控制输出阵列的运行时类型，并且在某些情况下可以用于节省分配成本。
    
    假设x是一个已知只包含字符串的队列。以下代码可用于将队列转储到新分配的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
  - spliterator
```
public Spliterator<E> spliterator()
```
    在此队列中的元素上返回Spliterator 。
    返回的分裂器是weakly consistent 。
    
    该Spliterator报告Spliterator.CONCURRENT ， Spliterator.ORDERED和Spliterator.NONNULL 。
    
    Specified by:
    
    spliterator在界面 Collection<E>
    
    Specified by:
    
    spliterator在界面 Iterable<E>
    
    Implementation Note:
    
    Spliterator实现了 trySplit以允许有限的并行性。
    
    结果
    
    一个 Spliterator覆盖此队列中的元素
    
    从以下版本开始：
    
    1.8
  - put
```
public void put(E e)
```
    将指定元素插入此队列的尾部。由于队列是无限制的，因此该方法永远不会阻塞。
    
    Specified by:
    
    put ，界面 BlockingQueue<E>
    
    参数
    
    e - 要添加的元素
    
    异常
    
    NullPointerException - 如果指定的元素为null
  - offer
```
public boolean offer(E e,
                     long timeout,
                     TimeUnit unit)
```
    将指定元素插入此队列的尾部。由于队列无限制，此方法永远不会阻止或返回false 。
    
    Specified by:
    
    offer ，界面 BlockingQueue<E>
    
    参数
    
    e - 要添加的元素
    
    timeout - 放弃前等待多长时间，单位为 unit
    
    unit -一个 TimeUnit确定如何解释 timeout参数
    
    结果
    
    true （由 BlockingQueue.offer指定）
    
    异常
    
    NullPointerException - 如果指定的元素为null
  - offer
```
public boolean offer(E e)
```
    将指定元素插入此队列的尾部。由于队列无限制，此方法永远不会返回false 。
    
    Specified by:
    
    offer在界面 BlockingQueue<E>
    
    Specified by:
    
    offer在界面 Queue<E>
    
    参数
    
    e - 要添加的元素
    
    结果
    
    true （由 Queue.offer(E)指定）
    
    异常
    
    NullPointerException - 如果指定的元素为null
  - add
```
public boolean add(E e)
```
    将指定元素插入此队列的尾部。由于队列无限制，此方法永远不会抛出IllegalStateException或返回false 。
    
    Specified by:
    
    add在界面 BlockingQueue<E>
    
    Specified by:
    
    add在界面 Collection<E>
    
    Specified by:
    
    add在界面 Queue<E>
    
    重写：
    
    add在类 AbstractQueue<E>
    
    参数
    
    e - 要添加的元素
    
    结果
    
    true （由 Collection.add(E)指定）
    
    异常
    
    NullPointerException - 如果指定的元素为null
  - tryTransfer
```
public boolean tryTransfer(E e)
```
    如果可能，立即将元素转移给等待的消费者。
    更确切地说，如果存在已经等待接收它的消费者（在BlockingQueue.take()或定时poll中），则立即传送指定元素，否则返回false而不将该元素排队。
    
    Specified by:
    
    tryTransfer在接口 TransferQueue<E>
    
    参数
    
    e - 要转移的元素
    
    结果
    
    true如果元素已转移， false
    
    异常
    
    NullPointerException - 如果指定的元素为null
  - transfer
```
public void transfer(E e)
              throws InterruptedException
```
    将元素传输给消费者，在必要时等待。
    更确切地说，如果存在已经等待接收它的消费者（在BlockingQueue.take()或定时poll中），则立即传送指定的元素，否则在该队列的尾部插入指定的元素并等待消费者接收该元素。
    
    Specified by:
    
    transfer在界面 TransferQueue<E>
    
    参数
    
    e - 要转移的元素
    
    异常
    
    NullPointerException - 如果指定的元素为null
    
    InterruptedException - 如果在等待时被中断，在这种情况下该元素不会被排队
  - tryTransfer
```
public boolean tryTransfer(E e,
                           long timeout,
                           TimeUnit unit)
                    throws InterruptedException
```
    如果可以在超时过去之前执行此操作，则将元素传输给使用者。
    更确切地说，如果存在已经等待接收它的消费者（在BlockingQueue.take()或定时poll中），则立即传送指定的元素，否则在该队列的尾部插入指定的元素并等待消费者接收该元素，返回false如果在传输元素之前经过了指定的等待时间。
    
    Specified by:
    
    tryTransfer在界面 TransferQueue<E>
    
    参数
    
    e - 要转移的元素
    
    timeout - 放弃前等待多长时间，单位为 unit
    
    unit -一个 TimeUnit确定如何解释 timeout参数
    
    结果
    
    true如果成功，或 false如果指定的等待时间在完成之前过去，在这种情况下该元素不会被排队
    
    异常
    
    NullPointerException - 如果指定的元素为null
    
    InterruptedException - 如果在等待时被中断，则在这种情况下该元素不会被排队
  - drainTo
```
public int drainTo(Collection<? super E> c)
```
    从界面复制的说明： BlockingQueue
    
    从此队列中删除所有可用元素，并将它们添加到给定集合中。此操作可能比重复轮询此队列更有效。尝试将元素添加到集合c遇到的故障可能导致在抛出关联的异常时元素既不在集合中，也不在集合中。尝试将队列排入自身会导致IllegalArgumentException 。此外，如果在操作正在进行时修改了指定的集合，则此操作的行为是不确定的。
    
    Specified by:
    
    drainTo in interface BlockingQueue<E>
    
    参数
    
    c - 将元素转换为的集合
    
    结果
    
    转移的元素数量
    
    异常
    
    NullPointerException - 如果指定的集合为null
    
    IllegalArgumentException - 如果指定的集合是此队列，或此队列的某个元素的某些属性阻止将其添加到指定的集合
  - drainTo
```
public int drainTo(Collection<? super E> c,
                   int maxElements)
```
    从界面复制的说明： BlockingQueue
    
    从该队列中删除最多给定数量的可用元素，并将它们添加到给定集合中。尝试向集合c添加元素时遇到的故障可能导致在抛出关联的异常时元素既不在集合中，也不在集合中。尝试将队列排入自身会导致IllegalArgumentException 。此外，如果在操作正在进行时修改了指定的集合，则此操作的行为是不确定的。
    
    Specified by:
    
    drainTo在界面 BlockingQueue<E>
    
    参数
    
    c - 将元素转移到的集合
    
    maxElements - 要传输的最大元素数
    
    结果
    
    转移的元素数量
    
    异常
    
    NullPointerException - 如果指定的集合为null
    
    IllegalArgumentException - 如果指定的集合是此队列，或此队列的某个元素的某些属性阻止将其添加到指定的集合
  - iterator
```
public Iterator<E> iterator()
```
    以适当的顺序返回此队列中元素的迭代器。元素将从第一个（头部）到最后一个（尾部）按顺序返回。
    返回的迭代器是weakly consistent 。
    
    Specified by:
    
    iterator在界面 Collection<E>
    
    Specified by:
    
    iterator在界面 Iterable<E>
    
    Specified by:
    
    iterator类 AbstractCollection<E>
    
    结果
    
    以适当的顺序在此队列中的元素上的迭代器
  - isEmpty
```
public boolean isEmpty()
```
    如果此队列不包含任何元素，则返回 true 。
    
    Specified by:
    
    isEmpty在接口 Collection<E>
    
    重写：
    
    isEmpty在类 AbstractCollection<E>
    
    结果
    
    true如果此队列不包含任何元素
  - size
```
public int size()
```
    返回此队列中的元素数。如果此队列包含超过Integer.MAX_VALUE元素，则返回Integer.MAX_VALUE 。
    请注意，与大多数集合不同，此方法不是恒定时间操作。由于这些队列的异步性质，确定当前元素数需要O（n）遍历。
    
    Specified by:
    
    size在界面 Collection<E>
    
    结果
    
    此队列中的元素数
  - remove
```
public boolean remove(Object o)
```
    从此队列中删除指定元素的单个实例（如果存在）。更正式地，如果此队列包含一个或多个此类元素，则删除元素e ，使得o.equals(e) 。如果此队列包含指定的元素，则返回true （或等效地，如果此队列因调用而更改）。
    
    Specified by:
    
    remove在接口 BlockingQueue<E>
    
    Specified by:
    
    remove在界面 Collection<E>
    
    重写：
    
    remove在类 AbstractCollection<E>
    
    参数
    
    o - 要从此队列中删除的元素（如果存在）
    
    结果
    
    true如果此队列因调用而更改
  - contains
```
public boolean contains(Object o)
```
    如果此队列包含指定的元素，则返回true 。更正式的，返回true当且仅当此队列包含至少一个元素e这样o.equals(e) 。
    
    Specified by:
    
    contains在界面 BlockingQueue<E>
    
    Specified by:
    
    contains在界面 Collection<E>
    
    重写：
    
    contains在类 AbstractCollection<E>
    
    参数
    
    o - 要在此队列中检查包含的对象
    
    结果
    
    true如果此队列包含指定的元素
  - remainingCapacity
```
public int remainingCapacity()
```
    始终返回 Integer.MAX_VALUE因为 LinkedTransferQueue不受容量限制。
    
    Specified by:
    
    remainingCapacity在界面 BlockingQueue<E>
    
    结果
    
    Integer.MAX_VALUE （由 BlockingQueue.remainingCapacity()指定）
  - removeIf
```
public boolean removeIf(Predicate<? super E> filter)
```
    从界面复制的说明： Collection
    
    删除此集合中满足给定谓词的所有元素。在迭代期间或通过谓词抛出的错误或运行时异常被中继到调用者。
    
    Specified by:
    
    removeIf in interface Collection<E>
    
    参数
    
    filter - 一个谓词，它返回 true表示要删除的元素
    
    结果
    
    true是否删除了任何元素
    
    异常
    
    NullPointerException - 如果指定的过滤器为null
  - removeAll
```
public boolean removeAll(Collection<?> c)
```
    从类： AbstractCollection复制的说明
    
    删除此集合的所有元素，这些元素也包含在指定的集合中（可选操作）。此调用返回后，此集合将不包含与指定集合相同的元素。
    
    Specified by:
    
    removeAll在界面 Collection<E>
    
    重写：
    
    removeAll类 AbstractCollection<E>
    
    参数
    
    c - 包含要从此集合中删除的元素的集合
    
    结果
    
    true如果此集合因呼叫而更改
    
    异常
    
    NullPointerException - 如果此集合包含一个或多个null元素且指定的集合不支持null元素（ optional ），或者指定的集合为null
    
    另请参见：
    
    AbstractCollection.remove(Object) ， AbstractCollection.contains(Object)
  - retainAll
```
public boolean retainAll(Collection<?> c)
```
    复制自类的说明： AbstractCollection
    
    仅保留此集合中包含在指定集合中的元素（可选操作）。换句话说，从此集合中删除未包含在指定集合中的所有元素。
    
    Specified by:
    
    retainAll ，界面 Collection<E>
    
    重写：
    
    retainAll在课程 AbstractCollection<E>
    
    参数
    
    c - 包含要在此集合中保留的元素的集合
    
    结果
    
    true如果此集合因呼叫而更改
    
    异常
    
    NullPointerException - 如果此集合包含一个或多个null元素且指定的集合不允许null元素（ optional ），或者指定的集合为null
    
    另请参见：
    
    AbstractCollection.remove(Object) ， AbstractCollection.contains(Object)
  - forEach
```
public void forEach(Consumer<? super E> action)
```
    从界面复制的说明： Iterable
    
    对Iterable每个元素执行给定操作，直到处理Iterable所有元素或操作抛出异常为止。如果指定了该顺序，则按迭代顺序执行操作。操作抛出的异常将转发给调用者。
    如果操作执行修改元素的基础源的副作用，则此方法的行为未指定，除非重写类已指定并发修改策略。
    
    Specified by:
    
    forEach在界面 Iterable<E>
    
    参数
    
    action - 要为每个元素执行的操作
    
    异常
    
    NullPointerException - if the specified action is null

Class LinkedTransferQueue<E>

构造方法摘要

方法摘要

声明方法的类 java.util.AbstractQueue

声明方法的类 java.util.AbstractCollection

声明方法的类 java.lang.Object

声明方法的接口 java.util.concurrent.BlockingQueue

声明方法的接口 java.util.Collection

声明方法的接口 java.util.Queue

声明方法的接口 java.util.concurrent.TransferQueue

构造方法详细信息

LinkedTransferQueue

LinkedTransferQueue

方法详细信息

toArray

toArray

spliterator

put

offer

offer

add

tryTransfer

transfer

tryTransfer

drainTo

drainTo

iterator

isEmpty

size

remove

contains

remainingCapacity

removeIf

removeAll

retainAll

forEach