Programa Java para implementar la API LinkedBlockingDeque

Java

// Java program to show the implementation
// of LinkedBlockingDeque API
 
import java.util.*;
import java.util.Collection;
import java.util.Iterator;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.TimeUnit;
 
class LinkedBlockingDequeImpl<E> {
    private LinkedBlockingDeque<E> linkedBlockingDeque;
 
    // constructor to create a LinkedBlockingDeque .
    public LinkedBlockingDequeImpl()
    {
        linkedBlockingDeque = new LinkedBlockingDeque<E>();
    }
 
    // constructor to create a LinkedBlockingDeque initially
    // containing the elements of the given collection
    public LinkedBlockingDequeImpl(
        Collection<? extends E> collection)
    {
        linkedBlockingDeque
            = new LinkedBlockingDeque<E>(collection);
    }
 
    // constructor to create a LinkedBlockingDeque with
    // specified capacity.
    public LinkedBlockingDequeImpl(int cap)
    {
        linkedBlockingDeque
            = new LinkedBlockingDeque<E>(cap);
    }
 
    // method to remove all of the elements from the deque.
    public void clear() { linkedBlockingDeque.clear(); }
 
    // method to check if deque contains the specified
    // element.
    public boolean contains(Object object)
    {
        return linkedBlockingDeque.contains(object);
    }
 
    // method to remove all of the elements from the deque
    // and add them to specified collection.
    public int drainTo(Collection<? super E> collection)
    {
        return linkedBlockingDeque.drainTo(collection);
    }
 
    // method to remove specified number of the elements
    // from the deque and add them to specified collection.
    public int drainTo(Collection<? super E> collection,
                       int maxElement)
    {
        return linkedBlockingDeque.drainTo(collection,
                                           maxElement);
    }
 
    // method to return an iterator over the elements in
    // this deque .
    public Iterator<E> iterator()
    {
        return linkedBlockingDeque.iterator();
    }
 
    // method to insert a specified element at the tail of
    // this queue. Return true upon successful insertion
    // else return false.
    public boolean offer(E element)
    {
        return linkedBlockingDeque.offer(element);
    }
 
    // method to insert a specified element at the tail of
    // this queue. Return true upon successful insertion
    // else return false.
    public boolean offer(E element, long timeout,
                         TimeUnit unit)
        throws InterruptedException
    {
        return linkedBlockingDeque.offer(element, timeout,
                                         unit);
    }
 
    // method to retrieve element from head of deque .
    public E peek() { return linkedBlockingDeque.peek(); }
 
    // method to remove and retrieve element from head of
    // deque .
    public E poll() { return linkedBlockingDeque.poll(); }
 
    // method to remove and retrieve element from head of
    // deque .
    public E poll(long timeout, TimeUnit unit)
        throws InterruptedException
    {
        return linkedBlockingDeque.poll(timeout, unit);
    }
 
    // method to insert the specified element at the tail of
    // the deque.
    public void put(E element) throws InterruptedException
    {
        linkedBlockingDeque.put(element);
    }
 
    // method to return the number of additional elements
    // that the deque can ideally accept without blocking.
    public int remainingCapacity()
    {
        return linkedBlockingDeque.remainingCapacity();
    }
 
    // method to remove a single instance of the
    // specified element from the deque
    public boolean remove(Object object)
    {
        return linkedBlockingDeque.remove(object);
    }
 
    // method to return the number of elements in the deque.
    public int size() { return linkedBlockingDeque.size(); }
 
    // method to retrieve and remove the head of the deque.
    public E take() throws InterruptedException
    {
        return linkedBlockingDeque.take();
    }
 
    // method to return an array containing all of
    // the elements in the deque.
    public Object[] toArray()
    {
        return linkedBlockingDeque.toArray();
    }
 
    // method to return an array containing all of
    // the elements in the deque
    public <T> T[] toArray(T[] array)
    {
        return linkedBlockingDeque.toArray(array);
    }
 
    // method to return a string representation of the
    // collection
    public String toString()
    {
        return linkedBlockingDeque.toString();
    }
 
    // method to insert specified element at the front of
    // the deque.
    public void addFirst(E element)
    {
        linkedBlockingDeque.addFirst(element);
    }
 
    // method to insert specified element at the end of the
    // deque.
    public void addLast(E element)
    {
        linkedBlockingDeque.addLast(element);
    }
 
    // method to retrieve first element of the deque.
    public void getFirst()
    {
        linkedBlockingDeque.getFirst();
    }
 
    // method to retrieve the last element of the deque.
    public void getLast() { linkedBlockingDeque.getLast(); }
 
    // Inserts the specified element at the front of this
    // deque
    public boolean offerFirst(E element)
    {
        return linkedBlockingDeque.offerFirst(element);
    }
 
    // method to insert a specified element at the end of
    // the deque.
    public boolean offerLast(E element)
    {
        return linkedBlockingDeque.offerLast(element);
    }
 
    // method to retrieve first element of the deque .
    public E peekFirst()
    {
        return linkedBlockingDeque.peekFirst();
    }
 
    // method to retrieve last element of the deque .
    public E peekLast()
    {
        return linkedBlockingDeque.peekLast();
    }
}
 
public class LinkedBlockingDequeDemo {
    public static void main(String[] args)
        throws InterruptedException
    {
       
        // create object of LinkedBlockingDeque
        // using LinkedBlockingDeque() constructor
        LinkedBlockingDequeImpl<Integer> linkedBlockingDeque
            = new LinkedBlockingDequeImpl<Integer>();
       
        try {
           
            // Add numbers to end of LinkedBlockingDeque
            linkedBlockingDeque.put(10);
            linkedBlockingDeque.put(20);
            linkedBlockingDeque.put(30);
        }
       
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
       
        System.out.println(
            "the elements of the linkedBlockingDeque is ");
       
        Iterator<Integer> itr = linkedBlockingDeque.iterator();
       
        while (itr.hasNext())
        {
            System.out.print(itr.next() + "\t");
        }
       
        System.out.println();
       
        linkedBlockingDeque.offer(60);
        linkedBlockingDeque.offer(70);
       
        System.out.println(
            "the peak element of the linkedBlockingDeque is(by peeking) "
            + linkedBlockingDeque.peek());
       
        System.out.println(
            "the peak element of the linkedBlockingDeque is(by polling) "
            + linkedBlockingDeque.poll());
       
        System.out.println(
            "the remaining capacity is "
            + linkedBlockingDeque.remainingCapacity());
       
        System.out.println(
            "element 30 removed "
            + linkedBlockingDeque.remove(30));
       
        System.out.println(
            "the linkedBlockingDeque contains 40 :"
            + linkedBlockingDeque.contains(40));
       
        System.out.println(
            "the linkedBlockingDeque contains 10 :"
            + linkedBlockingDeque.contains(10));
       
        System.out.println(
            "the size of the linkedBlockingDeque is "
            + linkedBlockingDeque.size());
       
        System.out.println(linkedBlockingDeque);
    }
}