Java Program to Implement ConcurrentLinkedQueue API

// Java program to demonstrate the
// implementation of ConcurrentLinkedQueue API

import java.util.Collection;
import java.util.Iterator;
import java.util.concurrent.ConcurrentLinkedQueue;

class ConcurrentLinkedQueueImplmentation<E> {

    private ConcurrentLinkedQueue<E> concurrentLinkedQueue;

    // Constructor creates a new empty ConcurrentLinkedQueue
    public ConcurrentLinkedQueueImplmentation()
    {

        // New empty concurrentLinkedQueue
        concurrentLinkedQueue = new ConcurrentLinkedQueue<>();
    }

    // Constructor creates a new ConcurrentLinkedQueue of
    // type E
    public ConcurrentLinkedQueueImplmentation(Collection<? extends E> c)
    {
        // New empty concurrentLinkedQueue
        concurrentLinkedQueue = new ConcurrentLinkedQueue<>(c);
    }

    // Add specified element to the tail of the queue
    public boolean add(E e)
    {
        // Add element
        return concurrentLinkedQueue.add(e);
    }

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

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

    // Add the specified element at the tail of the queue
    public boolean offer(E e)
    {
        return concurrentLinkedQueue.offer(e);
    }

    // Returns the peek of the queue or returns null if this
    // queue is empty.
    public E peek() { return concurrentLinkedQueue.peek(); }

    // Retrieves and removes the head of this queue, or
    // returns null if this queue is empty

    public E poll() { return concurrentLinkedQueue.poll(); }
  
    // Removes a single instance of the specified element
    // from this queue, if it is present.
    public boolean remove(Object o)
    {
        return concurrentLinkedQueue.remove(o);
    }

    // Returns the size of the queue
    public int size()
    {
        return concurrentLinkedQueue.size();
    }

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

    // Returns an array containing all of the elements in
    // this queue, in proper sequence; the return type of
    // the array is that of the specified
    //  array.
    public <T> T[] toArray(T[] a)
    {
        return concurrentLinkedQueue.toArray(a);
    }
}

public class GFG {
    public static void main(String[] arg)
    {

        // New ConcurrentLinkedQueue
        ConcurrentLinkedQueueImplmentation<Integer>
            concurrentLinkedQueue
            = new ConcurrentLinkedQueueImplmentation<
                Integer>();

        // Adding elements to the ConcurrentLinkedQueue
        concurrentLinkedQueue.add(10);
        concurrentLinkedQueue.add(20);
        concurrentLinkedQueue.add(30);
        concurrentLinkedQueue.add(40);
        concurrentLinkedQueue.add(50);

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

        // Iterator to iterate over ConcurrentLinkedQueue
        Iterator<Integer> it
            = concurrentLinkedQueue.iterator();

        // Iterate over ConcurrentLinkedQueue
        while (it.hasNext()) 
        {
            System.out.print(it.next() + " ");
        }

        System.out.println();

        // Print the size of the queue
        System.out.println("Size of the concurrentLinkedQueue is: "
            + concurrentLinkedQueue.size());

        System.out.println();

        // Print Peek element of the queue
        System.out.println("The peek element of the concurrentLinkedQueue is: "
            + concurrentLinkedQueue.peek());

        System.out.println();

        // Print the polled element of the queue
        System.out.println("The polled element of the concurrentLinkedQueue is: "
            + concurrentLinkedQueue.poll());

        System.out.println();

        // Remove specified element to the queue, returns
        // true if removed successfully or returns null if
        // element not present in the queue
        System.out.println("Remove 30: "
            + concurrentLinkedQueue.remove(30));

        System.out.println();

        // Check whether the spaecified element is present
        // or not in the queue
        System.out.println("The concurrentLinkedQueue contains 40:"
            + concurrentLinkedQueue.contains(40));

        System.out.println();

        // Print the size of the queue
        System.out.println("Size of the concurrentLinkedQueue is: "
            + concurrentLinkedQueue.size());
    }
}