xxxxxxxxxx
import java.util.*;
Queue<Integer> queue = new LinkedList<Integer>();
// use non-primative types when constructing
// to add a value to the back of queue:
queue.add(7);
// to remove and return front value:
int next = queue.remove();
// to just return front value without removing:
int peek = queue.peek();
xxxxxxxxxx
queues, //add, remove, peek , size()
Queue<Integer> q = new LinkedList<>();
- Unlike stacks, a queue is open at both its ends. (one end enqueue & one end remove data, dequeue) FIFO
- enqueue() − add (store) an item to the queue.
- dequeue() − remove (access) an item from the queue.
- peek() − Gets the element at the front of the queue without removing it.
- isfull() − Checks if the queue is full.
- isempty() − Checks if the queue is empty.
Queue<Integer> queue = new LinkedList<Integer>();
queue.add(10);
queue.add(20);
int a = queue.remove();
int peek = queue.peek();
System.out.println(queue + " " + a); //[20] 10
xxxxxxxxxx
// LinkedList implementation of Queue
Queue<String> animal1 = new LinkedList<>();
// Array implementation of Queue
Queue<String> animal2 = new ArrayDeque<>();
// Priority Queue implementation of Queue
Queue<String> animal 3 = new PriorityQueue<>();
xxxxxxxxxx
import java.util.*;
public class Main {
public static void main(String[] args) {
Queue<Integer> q1 = new LinkedList<Integer>();
//Add elements to the Queue
q1.add(10);
q1.add(20);
q1.add(30);
q1.add(40);
q1.add(50);
System.out.println("Elements in Queue:"+q1);
//remove () method =>removes first element from the queue
System.out.println("Element removed from the queue: "+q1.remove());
//element() => returns head of the queue
System.out.println("Head of the queue: "+q1.element());
//poll () => removes and returns the head
System.out.println("Poll():Returned Head of the queue: "+q1.poll());
//returns head of the queue
System.out.println("peek():Head of the queue: "+q1.peek());
//print the contents of the Queue
System.out.println("Final Queue:"+q1);
}
}
xxxxxxxxxx
import java.util.LinkedList;
import java.util.Queue;
public class Main {
public static void main(String[] args) {
// Create a queue
Queue<String> queue = new LinkedList<>();
// Add elements to the queue
queue.offer("element1");
queue.offer("element2");
queue.offer("element3");
// Remove and retrieve the head of the queue
String head = queue.poll();
System.out.println("Head of the queue: " + head);
// Check if the queue is empty
boolean isEmpty = queue.isEmpty();
System.out.println("Is the queue empty? " + isEmpty);
// Get the size of the queue
int size = queue.size();
System.out.println("Size of the queue: " + size);
}
}
xxxxxxxxxx
The Queue interface is available in java.util package and extends the Collection interface. The queue collection is used to hold the elements about to be processed and provides various operations like the insertion, removal etc. It is an ordered list of objects with its use limited to insert elements at the end of the list and deleting elements from the start of list i.e. it follows the FIFO or the First-In-First-Out principle.
LinkedList, ArrayBlockingQueue and PriorityQueue are the most frequently used implementations.
xxxxxxxxxx
//this a basic one
public class prosses {
int [] s;
int quu;
int tu;
prosses () {//constructor
s = new int[20];
quu = -1;
tu = 0;
}
void enqueue (int d) {//for input and prosses
if (quu >= 19) {
System.out.println("stack is full");
} else {
s[++quu] = d;
}
}
int dequeue(){//to send the output
if(quu<0 && quu>19 && tu<0 && tu>19) {
System.out.println("not possible");
return 'n';
}
return s[tu++];
}
}