Java Program to Implement LinkedBlockingQueue API

// Java Program to Implement LinkedBlockingQueue API

import java.util.Collection;
import java.util.Iterator;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class BlockingQueue<E> {
    private LinkedBlockingQueue<E> q;

    // Creates a LinkedBlockingQueue with a size of
    // Integer.MAX_VALUE.
    public BlockingQueue()
    {
        q = new LinkedBlockingQueue<E>();
    }

    // Creates a LinkedBlockingQueue initially containing
    // the elements of the given collection
    public BlockingQueue(Collection<? extends E> c)
    {
        q = new LinkedBlockingQueue<E>(c);
    }

    // Creates a LinkedBlockingQueue with the given size
    public BlockingQueue(int size)
    {
        q = new LinkedBlockingQueue<E>(size);
    }

    // Returns true if the queue contains the given element
    public boolean contains(Object o)
    {
        return q.contains(o);
    }

    // Removes all elements from the queue and adds them to
    // the given collection.
    public int drainTo(Collection<? super E> c)
    {
        return q.drainTo(c);
    }

    //  Removes the elements from the queue and adds them to
    //  the given collection.
    public int drainTo(Collection<? super E> c, int maxEle)
    {
        return q.drainTo(c, maxEle);
    }

    // Returns an iterator over the elements in the queue
    public Iterator<E> iterator() { return q.iterator(); }

    // removes all the elements from the queue.
    void clear() { q.clear(); }

    // Inserts the given element at the end of the queue,
    // returning true upon inserting and false if the queue
    // is full.
    public boolean offer(E e) { return q.offer(e); }

    // inserts then given element at the end and wait for
    // the given time for the space to become available
    public boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException
    {
        return q.offer(e, timeout, unit);
    }

    // Retrieves, but does not remove, the head of the
    // queue, or returns null if this queue is empty.
    public E peek() { return q.peek(); }

    //  Retrieves and removes the head of the queue
    public E poll() { return q.poll(); }

    // Retrieves and removes the head of the queue and wait
    // for the specified time for the element to become
    // available.
    public E poll(long tout, TimeUnit un)
        throws InterruptedException
    {
        return q.poll(tout, un);
    }

    // Returns the number of additional elements that the
    // queue can contain without blocking.
    public int remainingCapacity()
    {
        return q.remainingCapacity();
    }

    // Removes the specified element from the queue
    public boolean remove(Object o) { return q.remove(o); }

    // Returns the number of elements in the queue
    public int size() { return q.size(); }

    // Inserts the given element at the end of the queue,
    // wait for space to become available
    public void put(E e) throws InterruptedException
    {
        q.put(e);
    }

    // Retrieves and removes the head of the queue wait till
    // an element becomes available
    public E take() throws InterruptedException
    {
        return q.take();
    }

    // Returns an array containing all the elements in the
    // queue.
    public Object[] toArray() { return q.toArray(); }

    // Returns an array containing all of the elements in
    // the queue
    public <T> T[] toArray(T[] a) { return q.toArray(a); }

    // Returns a string representation of the collection.
    public String toString() { return q.toString(); }

    public static void main(String[] args)
    {
        BlockingQueue<Integer> q
            = new BlockingQueue<Integer>();
        try {
            q.put(1);
            q.put(2);
            q.put(3);
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(
            "The elements of the LinkedBlockingQueue is ");

        Iterator<Integer> i = q.iterator();

        while (i.hasNext()) {
            System.out.print(i.next() + "\t");
        }
        System.out.println();

        System.out.println("The remaining capacity is "
                           + q.remainingCapacity());

        System.out.println("3 removed " + q.remove(3));

        q.offer(6);
        q.offer(7);

        System.out.println(
            "The peak element of the LinkedBlockingQueue is "
            + q.peek());

        System.out.println(
            "The peak element of the LinkedBlockingQueue is "
            + q.poll());

        System.out.println(
            "The LinkedBlockingQueue contains 4 :"
            + q.contains(4));

        System.out.println(
            "The LinkedBlockingQueue contains 1 :"
            + q.contains(1));

        System.out.println(
            "The size of the LinkedBlockingQueue is "
            + q.size());

        System.out.println(q);
    }
}