This Java program Implements LinkedBlockigngDeque API.The optional capacity bound constructor argument serves as a way to prevent excessive expansion. The capacity, if unspecified, is equal to Integer.MAX_VALUE. Linked nodes are dynamically created upon each insertion unless this would bring the deque above capacity.
Here is the source code of the Java Program to Implement LinkedBlockingDeque API. The Java program is successfully compiled and run on a Linux system. The program output is also shown below.
import java.util.Collection; import java.util.Iterator; import java.util.concurrent.LinkedBlockingDeque; import java.util.concurrent.TimeUnit; public class LinkedBlockingDequeImpl<E> { private LinkedBlockingDeque<E> linkedBlockingDeque; /** Creates a LinkedBlockingDeque with a capacity of Integer.MAX_VALUE. **/ public LinkedBlockingDequeImpl() { linkedBlockingDeque = new LinkedBlockingDeque<E>(); } /** * Creates a LinkedBlockingDeque with a capacity of Integer.MAX_VALUE, * initially containing the elements of the given collection, added in * traversal order of the collection's iterator. **/ public LinkedBlockingDequeImpl(Collection<? extends E> c) { linkedBlockingDeque = new LinkedBlockingDeque<E>(c); } /** Creates a LinkedBlockingDeque with the given (fixed) capacity. **/ public LinkedBlockingDequeImpl(int capacity) { linkedBlockingDeque = new LinkedBlockingDeque<E>(capacity); } /** Atomically removes all of the elements from this deque. **/ public void clear() { linkedBlockingDeque.clear(); } /** Returns true if this deque contains the specified element. **/ public boolean contains(Object o) { return linkedBlockingDeque.contains(o); } /** * Removes all available elements from this deque and adds them to the given * collection. **/ public int drainTo(Collection<? super E> c) { return linkedBlockingDeque.drainTo(c); } /** * Removes at most the given number of available elements from this deque * and adds them to the given collection. **/ public int drainTo(Collection<? super E> c, int maxElements) { return linkedBlockingDeque.drainTo(c, maxElements); } /** Returns an iterator over the elements in this deque in proper sequence. **/ public Iterator<E> iterator() { return linkedBlockingDeque.iterator(); } /** * Inserts the specified element at the tail of this queue if it is possible * to do so immediately without exceeding the queue's capacity, returning * true upon success and false if this deque is full. **/ public boolean offer(E e) { return linkedBlockingDeque.offer(e); } /** * Inserts the specified element at the tail of this queue, waiting up to * the specified wait time for space to become available if the deque is * full. **/ public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException { return linkedBlockingDeque.offer(e, timeout, unit); } /** * Retrieves, but does not remove, the head of this deque, or returns null * if this queue is empty. **/ public E peek() { return linkedBlockingDeque.peek(); } /** * Retrieves and removes the head of this deque, or returns null if this * queue is empty. **/ public E poll() { return linkedBlockingDeque.poll(); } /** * Retrieves and removes the head of this deque, waiting up to the specified * wait time if necessary for an element to become available. **/ public E poll(long timeout, TimeUnit unit) throws InterruptedException { return linkedBlockingDeque.poll(timeout, unit); } /** * Inserts the specified element at the tail of this deque, waiting for * space to become available if the queue is full. **/ public void put(E e) throws InterruptedException { linkedBlockingDeque.put(e); } /** * Returns the number of additional elements that this deque can ideally (in * the absence of memory or resource constraints) accept without blocking. **/ public int remainingCapacity() { return linkedBlockingDeque.remainingCapacity(); } /** * Removes a single instance of the specified element from this deque, if it * is present. **/ public boolean remove(Object o) { return linkedBlockingDeque.remove(o); } . /** Returns the number of elements in this deque. **/ public int size() { return linkedBlockingDeque.size(); } /** * Retrieves and removes the head of this deque, waiting if necessary until * an element becomes available . **/ public E take() throws InterruptedException { return linkedBlockingDeque.take(); } /** * Returns an array containing all of the elements in this deque, in proper * sequence. **/ public Object[] toArray() { return linkedBlockingDeque.toArray(); } /** * Returns an array containing all of the elements in this deque, in proper * sequence; the runtime type of the returned array is that of the specified * array. **/ public <T> T[] toArray(T[] a) { return linkedBlockingDeque.toArray(a); } /** Returns a string representation of this collection. **/ public String toString() { return linkedBlockingDeque.toString(); } /** Inserts the specified element at the front of this deque. **/ public void addFirst(E e) { linkedBlockingDeque.addFirst(e); } /** Inserts the specified element at the end of this deque. **/ public void addLast(E e) { linkedBlockingDeque.addLast(e); } /** Retrieves, but does not remove, the first element of this deque. **/ public void getFirst() { linkedBlockingDeque.getFirst(); } /** Retrieves, but does not remove, the last element of this deque. **/ public void getLast() { linkedBlockingDeque.getLast(); } /** Inserts the specified element at the front of this deque. **/ public boolean offerFirst(E e) { return linkedBlockingDeque.offerFirst(e); } /** Inserts the specified element at the end of this deque. **/ public boolean offerLast(E e) { return linkedBlockingDeque.offerLast(e); } /** * Retrieves, but does not remove, the first element of this deque, or * returns null if this deque is empty. **/ public E peekFirst() { return linkedBlockingDeque.peekFirst(); } /** * Retrieves, but does not remove, the last element of this deque, or * returns null if this deque is empty. **/ public E peekLast() { return linkedBlockingDeque.peekLast(); } public static void main(String... arg) { LinkedBlockingDequeImpl<Integer> linkedBlockingDeque = new LinkedBlockingDequeImpl<Integer>(); try { linkedBlockingDeque.put(100); linkedBlockingDeque.put(200); linkedBlockingDeque.put(300); } 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(600); linkedBlockingDeque.offer(700); 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 capcity is "+ linkedBlockingDeque.remainingCapacity()); System.out.println("element 300 removed " + linkedBlockingDeque.remove(300)); System.out.println("the linkedBlockingDeque contains 400 :" + linkedBlockingDeque.contains(400)); System.out.println("the linkedBlockingDeque contains 100 :" + linkedBlockingDeque.contains(100)); System.out.println("the size of the linkedBlockingDeque is "+ linkedBlockingDeque.size()); System.out.println(linkedBlockingDeque); } }
$ javac LinkedBlockingDequeImpl.java $ java LinkedBlockingDequeImpl the elements of the linkedBlockingDeque is 100 200 300 the peak element of the linkedBlockingDeque is(by peeking) 100 the peak element of the linkedBlockingDeque is(by polling) 100 the remaining capcity is 2147483643 element 300 removed true the linkedBlockingDeque contains 400 :false the linkedBlockingDeque contains 600 :true the size of the linkedBlockingDeque is 3 [200, 600, 700]
Related posts:
Spring Boot Gradle Plugin
Java Program to Implement Fisher-Yates Algorithm for Array Shuffling
Java Program to Implement Suffix Tree
LinkedHashSet trong java
Java Program to Implement Double Ended Queue
Java Program to Compute Cross Product of Two Vectors
String Processing with Apache Commons Lang 3
Java Program to Check for balanced parenthesis by using Stacks
Changing Annotation Parameters At Runtime
How to Read a Large File Efficiently with Java
Java Program to Search Number Using Divide and Conquer with the Aid of Fibonacci Numbers
Java Program to Implement the Schonhage-Strassen Algorithm for Multiplication of Two Numbers
Java Program to Implement Shoelace Algorithm
Java Program to Implement LinkedHashSet API
“Stream has already been operated upon or closed” Exception in Java
Java Program to Generate All Possible Subsets with Exactly k Elements in Each Subset
Generating Random Numbers in a Range in Java
Apache Camel with Spring Boot
Spring Boot - Introduction
Java Program to Implement the Program Used in grep/egrep/fgrep
Java InputStream to String
Java Program to implement Dynamic Array
Java Program to Implement Interpolation Search Algorithm
Using Java Assertions
Java Program to Check if a Given Set of Three Points Lie on a Single Line or Not
DistinctBy in the Java Stream API
Allow user:password in URL
Map Serialization and Deserialization with Jackson
Tips for dealing with HTTP-related problems
Jackson – Unmarshall to Collection/Array
Initialize a HashMap in Java
Java Program to Optimize Wire Length in Electrical Circuit