import
java.util.Collection;
import
java.util.Iterator;
import
java.util.concurrent.LinkedTransferQueue;
import
java.util.concurrent.TimeUnit;
public
class
LinkedTransferQueueImpl<E> {
private
LinkedTransferQueue<E> linkedTransferQueue;
public
LinkedTransferQueueImpl()
{
linkedTransferQueue =
new
LinkedTransferQueue<E>();
}
public
LinkedTransferQueueImpl(
Collection<?
extends
E> c)
{
linkedTransferQueue =
new
LinkedTransferQueue<E>(c);
}
public
boolean
add(E e)
{
return
linkedTransferQueue.add(e);
}
public
void
clear() { linkedTransferQueue.clear(); }
public
boolean
contains(Object o)
{
return
linkedTransferQueue.contains(o);
}
public
int
getWaitingConsumerCount()
{
return
linkedTransferQueue
.getWaitingConsumerCount();
}
public
boolean
hasWaitingConsumer()
{
return
linkedTransferQueue.hasWaitingConsumer();
}
public
int
drainTo(Collection<?
super
E> c)
{
return
linkedTransferQueue.drainTo(c);
}
public
int
drainTo(Collection<?
super
E> c,
int
maxElements)
{
return
linkedTransferQueue.drainTo(c, maxElements);
}
public
Iterator<E> iterator()
{
return
linkedTransferQueue.iterator();
}
public
boolean
offer(E e)
{
return
linkedTransferQueue.offer(e);
}
public
boolean
offer(E e,
long
timeout, TimeUnit unit)
throws
InterruptedException
{
return
linkedTransferQueue.offer(e, timeout, unit);
}
public
E peek() {
return
linkedTransferQueue.peek(); }
public
E poll() {
return
linkedTransferQueue.poll(); }
public
E poll(
long
timeout, TimeUnit unit)
throws
InterruptedException
{
return
linkedTransferQueue.poll(timeout, unit);
}
public
void
put(E e)
throws
InterruptedException
{
linkedTransferQueue.put(e);
}
public
int
remainingCapacity()
{
return
linkedTransferQueue.remainingCapacity();
}
public
boolean
remove(Object o)
{
return
linkedTransferQueue.remove(o);
}
public
int
size() {
return
linkedTransferQueue.size(); }
public
E take()
throws
InterruptedException
{
return
linkedTransferQueue.take();
}
public
Object[] toArray()
{
return
linkedTransferQueue.toArray();
}
public
<T> T[] toArray(T[] a)
{
return
linkedTransferQueue.toArray(a);
}
public
String toString()
{
return
linkedTransferQueue.toString();
}
public
void
transfer(E e)
throws
InterruptedException
{
linkedTransferQueue.transfer(e);
}
public
static
void
main(String[] args)
{
LinkedTransferQueueImpl<String> linkedTransferQueue
=
new
LinkedTransferQueueImpl<String>();
try
{
linkedTransferQueue.put(
"1"
);
linkedTransferQueue.put(
"2"
);
linkedTransferQueue.put(
"3"
);
}
catch
(InterruptedException e) {
e.printStackTrace();
}
linkedTransferQueue.add(
"4"
);
linkedTransferQueue.add(
"5"
);
System.out.println(
"the elements of the linkedTransferQueue is "
);
Iterator<String> itr
= linkedTransferQueue.iterator();
while
(itr.hasNext()) {
System.out.print(itr.next() +
"\t"
);
}
System.out.println();
linkedTransferQueue.offer(
"6"
);
linkedTransferQueue.offer(
"7"
);
System.out.println(
"the peak element of the linkedTransferQueue is(by peeking) "
+ linkedTransferQueue.peek());
System.out.println(
"the peak element of the linkedTransferQueue is(by polling) "
+ linkedTransferQueue.poll());
System.out.println(
"the remaining capacity is "
+ linkedTransferQueue.remainingCapacity());
System.out.println(
"the remaining consumer waiting count : "
+ linkedTransferQueue
.getWaitingConsumerCount());
System.out.println(
"element 300 removed "
+ linkedTransferQueue.remove(
"3"
));
System.out.println(
"the linkedTransferQueue contains 400 :"
+ linkedTransferQueue.contains(
"4"
));
System.out.println(
"the linkedTransferQueue contains 100 :"
+ linkedTransferQueue.contains(
"1"
));
System.out.println(
"the size of the linkedTransferQueue is "
+ linkedTransferQueue.size());
System.out.println(linkedTransferQueue);
}
}