java queue queue methods
Neste tutorial, discutiremos o que é uma fila em Java, como usá-la, exemplo de fila Java, métodos de fila Java e implementação de interface de fila:
Uma fila é uma estrutura de dados linear ou uma coleção em Java que armazena elementos em uma ordem FIFO (primeiro a entrar, primeiro a sair).
A coleção de filas tem duas extremidades, ou seja, frontal e traseira. Os elementos são adicionados na parte traseira e removidos da frente.
=> Visite aqui para ver a série de treinamento Java para todos.
O que você aprenderá:
O que é uma fila Java?
Uma estrutura de dados da fila é representada conforme mostrado abaixo:
Conforme mostrado no diagrama acima, uma fila é uma estrutura com dois pontos, ou seja, início (frente) e fim (traseira). Os elementos são inseridos na fila na extremidade traseira e removidos da fila na frente.
Em Java, Queue é uma interface que faz parte do pacote java.util. A interface da fila estende a interface Java Collection.
A definição geral da interface Queue é:
public interface Queue extends CollectionComo a Queue é uma interface, ela não pode ser instanciada. Precisamos de algumas classes concretas para implementar a funcionalidade da interface Queue. Duas classes implementam a interface Queue, ou seja, LinkedList e PriorityQueue.
A seguir estão algumas das principais características da estrutura de dados da fila:
- A fila segue a ordem FIFO (primeiro a entrar, primeiro a sair). Isso significa que o elemento é inserido na fila no final e removido da fila no início.
- A interface de fila Java fornece todos os métodos da interface de coleção, como inserção, exclusão, etc.
- LinkedList e PriorityQueue são as classes que implementam a interface Queue. ArrayBlockingQueue é outra classe que implementa a interface Queue.
- As filas que fazem parte do pacote java.util podem ser classificadas como filas ilimitadas, enquanto as presentes em java.util. O pacote simultâneo é filas limitadas.
- O Deque é uma fila que suporta inserção e exclusão de ambas as extremidades.
- O deque é thread-safe.
- BlockingQueues são thread-safe e são usados para implementar problemas produtor-consumidor.
- BlockingQueues não permite elementos nulos. Uma NullPointerException é lançada se qualquer operação relacionada a valores nulos for tentada.
Como usar uma fila em Java?
Para usar uma fila em Java, devemos primeiro importar a interface da fila da seguinte maneira:
import java.util.queue; Ou
import java.util.*; Depois de importado, podemos criar uma fila como mostrado abaixo:
Queue str_queue = new LinkedList (); Como Queue é uma interface, usamos uma classe LinkedList que implementa a interface Queue para criar um objeto de fila.
Da mesma forma, podemos criar uma fila com outras classes concretas.
Queue str_pqueue = new PriorityQueue (); Queue int_queue = new ArrayDeque (); Agora que o objeto de fila foi criado, podemos inicializar o objeto de fila fornecendo os valores a ele por meio do método add, conforme mostrado abaixo.
str_queue.add(“one”); str_queue.add(“two”); str_queue.add(“three”);Exemplo de fila Java
import java.util.*; public class Main { public static void main(String() args) { //declare a Queue Queue str_queue = new LinkedList(); //initialize the queue with values str_queue.add('one'); str_queue.add('two'); str_queue.add('three'); str_queue.add('four'); //print the Queue System.out.println('The Queue contents:' + str_queue); } }Resultado:
O conteúdo da fila: (um, dois, três, quatro)
O exemplo acima mostra a declaração e inicialização de um objeto Queue. Em seguida, apenas imprimimos o conteúdo da fila.
Métodos de fila em Java
Nesta seção, discutiremos os métodos de API para a fila. A interface de fila suporta várias operações como inserir, excluir, peek, etc. Algumas operações levantam uma exceção, enquanto outras retornam um valor específico quando o método é bem-sucedido ou falha.
Observe que não há mudanças específicas na coleção de filas em Java 8. Os métodos abaixo também estão disponíveis em versões posteriores de Java, como Java 9, etc.
A tabela a seguir resume todos esses métodos.
| Método | Protótipo de Método | Descrição |
|---|---|---|
| Tamanho | tamanho interno () | Retorna o tamanho ou número de elementos na fila. |
| adicionar | adição booleana (E e) | Adiciona o elemento e à fila no final (cauda) da fila sem violar as restrições de capacidade. Retorna verdadeiro se for bem-sucedido ou IllegalStateException se a capacidade se esgotar. |
| olhadinha | E peek () | Retorna a cabeça (frente) da fila sem removê-la. |
| elemento | Elemento E () | Executa a mesma operação do método peek (). Lança NoSuchElementException quando a fila está vazia. |
| retirar | E remove () | Remove o início da fila e o retorna. Lança NoSuchElementException se a fila estiver vazia. |
| enquete | E poll () | Remove o início da fila e o retorna. Se a fila estiver vazia, ele retornará nulo. |
| Oferta | oferta booleana (E e) | Insira o novo elemento e na fila sem violar as restrições de capacidade. |
Iterando os elementos da fila
Podemos percorrer os elementos da fila usando o loop forEach ou um iterador. O programa fornecido a seguir implementa ambas as abordagens para percorrer a fila.
import java.util.*; public class Main { public static void main(String() args) { //declare a Queue Queue LL_queue = new LinkedList(); //initialize the Queue LL_queue.add('Value-0'); LL_queue.add('Value-1'); LL_queue.add('Value-2'); LL_queue.add('Value-3'); //traverse the Queue using Iterator System.out.println('The Queue elements through iterator:'); Iterator iterator = LL_queue.iterator(); while(iterator.hasNext()){ String element = (String) iterator.next(); System.out.print(element + ' '); } System.out.println('
The Queue elements using for loop:'); //use new for loop to traverse the Queue for(Object object : LL_queue) { String element = (String) object; System.out.print(element + ' '); } } }Resultado:
Os elementos Queue por meio do iterador:
Valor-0 Valor-1 Valor-2 Valor-3
Os elementos Queue usando loop for:
Valor-0 Valor-1 Valor-2 Valor-3
Implementação Java Queue
O programa abaixo demonstra os métodos que discutimos acima.
import java.util.*; public class Main { public static void main(String() args) { Queue q1 = new LinkedList(); //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); } } Resultado:
Elementos na fila: (10, 20, 30, 40, 50)
Elemento removido da fila: 10
Chefe da fila: 20
Enquete (): Retornado Chefe da fila: 20
peek (): Chefe da fila: 30
Fila final: (30, 40, 50)
Implementação Java Queue Array
A implementação da fila não é tão direta quanto a implementação da pilha. Em primeiro lugar, a fila contém dois ponteiros, traseiro e frontal. Além disso, diferentes operações são feitas em duas extremidades diferentes.
Para implementar a fila usando Arrays, primeiro declaramos uma matriz que conterá n número de elementos da fila.
Em seguida, definimos as seguintes operações a serem realizadas nesta fila.
# 1) Enfileirar: Uma operação para inserir um elemento na fila é Enqueue (função queueEnqueue no programa). Para inserir um elemento na extremidade traseira, precisamos primeiro verificar se a fila está cheia. Se estiver cheio, não podemos inserir o elemento. Se traseiro # 2) Retirar da fila: A operação para excluir um elemento da fila é Dequeue (função queueDequeue no programa). Primeiro, verificamos se a fila está vazia. Para que a operação de desenfileiramento funcione, deve haver pelo menos um elemento na fila. # 3) Frente: Este método retorna a frente da fila. # 4) Display: Este método atravessa a fila e exibe os elementos da fila. O seguinte programa Java demonstra a implementação de Array de Queue. Resultado: Fila inicial: Como implementamos a estrutura de dados Queue usando Arrays no programa acima, também podemos implementar a Queue usando Linked List. Implementaremos os mesmos métodos enqueue, dequeue, front e display neste programa. A diferença é que usaremos a estrutura de dados Linked List em vez de Array. O programa a seguir demonstra a implementação de Linked List de Queue em Java. Resultado: Elemento 6 adicionado à fila BlockingQueue é uma interface adicionada ao Java 1.5 e faz parte do java.util.concurrent pacote. Essa interface introduz o bloqueio caso o BlockingQueue esteja cheio ou vazio. Assim, quando uma thread acessa a fila e tenta inserir (enfileirar) elementos em uma fila que já está cheia, ela é bloqueada até que outra thread crie um espaço na fila (talvez por operação de desenfileiramento ou limpeza da fila). Da mesma forma, no caso de desenfileiramento, a operação é bloqueada se a fila estiver vazia até que o elemento fique disponível para a operação de desenfileiramento. Os métodos BlockingQueue usam alguma forma de controle de concorrência como bloqueios internos e são atômicos. O BlockingQueue é uma fila simultânea que gerencia as operações da fila simultaneamente. O BlockingQueue é mostrado abaixo: Observe que BlockingQueue não aceita valores nulos. Uma tentativa de inserir um valor nulo na fila resulta em NullPointerException. Algumas das implementações BlockingQueue fornecidas em Java são LinkedBlockingQueue, PriorityBlockingQueue, ArrayBlockingQueue e SynchonousQueue. Todas essas implementações são thread-safe. BlockingQueues são de dois tipos: Na fila limitada, a capacidade da fila é passada para o construtor da fila. A declaração da fila é a seguinte: BlockingQueue BlockingQueue = novo LinkedBlockingDeque (5); Na fila ilimitada, não definimos a capacidade da fila explicitamente e ela pode aumentar de tamanho. A capacidade é definida como Integer.MAX_VALUE. A declaração da fila ilimitada é a seguinte: BlockingQueue BlockingQueue = new LinkedBlockingDeque (); A interface BlockingQueue é usada principalmente para problemas do tipo produtor-consumidor em que o produtor produz os recursos e o consumidor os consome. P # 1) O que é uma fila em Java? Responda: Fila em Java é uma estrutura de dados ordenada linear que segue a ordem dos elementos FIFO (First In, First Out). Isso significa que o elemento inserido primeiro na fila será o primeiro elemento a ser removido. Em Java, a fila é implementada como uma interface que herda a interface Collection. Q # 2) É um Java thread-safe da Fila? Responda: Nem todas as filas são thread-safe, mas BlockingQueues em Java são thread-safe. Q # 3) O que é mais rápido - Empilhar ou Enfileirar? Responda: A pilha é mais rápida. Na pilha, os elementos são processados de apenas uma extremidade, portanto, nenhuma mudança é necessária. Mas na fila, os elementos precisam ser deslocados e ajustados, pois há dois ponteiros diferentes para inserir e excluir elementos. Q # 4) Quais são os tipos de fila? Resposta: As filas são dos seguintes tipos: Q # 5) Por que a fila é usada? Responda: A estrutura de dados da fila é usada para fins de sincronização. A fila também é usada para agendamento de disco e CPU. Neste tutorial, discutimos as filas simples juntamente com seus detalhes, como declarações, implementação de inicialização e métodos. Também aprendemos sobre a implementação de Array e LinkedList de Queue em Java. Em nossos próximos tutoriais, discutiremos mais tipos de filas em detalhes. => Verifique TODOS os tutoriais Java aqui. class Queue { private static int front, rear, capacity; private static int queue(); Queue(int size) { front = rear = 0; capacity = size; queue = new int(capacity); } // insert an element into the queue static void queueEnqueue(int item) { // check if the queue is full if (capacity == rear) { System.out.printf('
Queue is full
'); return; } // insert element at the rear else { queue(rear) = item; rear++; } return; } //remove an element from the queue static void queueDequeue() { // check if queue is empty if (front == rear) { System.out.printf('
Queue is empty
'); return; } // shift elements to the right by one place uptil rear else { for (int i = 0; i
A fila está vazia
Enfileirar após a operação de enfileiramento:
10 = 30 = 50 = 70 =
Elemento frontal da fila: 10
Fila está cheia
10 = 30 = 50 = 70 =
Enfileirar após duas operações de desenfileiramento: 50 = 70 =
Elemento da frente da fila: 50
Implementação Java Queue Linked List
qual o melhor downloader de musica para pc
class LinkedListQueue { private Node front, rear; private int queueSize; // queue size //linked list node private class Node { int data; Node next; } //default constructor - initially front & rear are null; size=0; queue is empty public LinkedListQueue() { front = null; rear = null; queueSize = 0; } //check if the queue is empty public boolean isEmpty() { return (queueSize == 0); } //Remove item from the front of the queue. public int dequeue() { int data = front.data; front = front.next; if (isEmpty()) { rear = null; } queueSize--; System.out.println('Element ' + data+ ' removed from the queue'); return data; } //Add data at the rear of the queue. public void enqueue(int data) { Node oldRear = rear; rear = new Node(); rear.data = data; rear.next = null; if (isEmpty()) { front = rear; } else { oldRear.next = rear; } queueSize++; System.out.println('Element ' + data+ ' added to the queue'); } //print front and rear of the queue public void print_frontRear() { System.out.println('Front of the queue:' + front.data + ' Rear of the queue:' + rear.data); } } class Main{ public static void main(String a()){ LinkedListQueue queue = new LinkedListQueue(); queue.enqueue(6); queue.enqueue(3); queue.print_frontRear(); queue.enqueue(12); queue.enqueue(24); queue.dequeue(); queue.dequeue(); queue.enqueue(9); queue.print_frontRear(); } }
Elemento 3 adicionado à fila
Frente da fila: 6 Traseira da fila: 3
Elemento 12 adicionado à fila
Elemento 24 adicionado à fila
Elemento 6 removido da fila
Elemento 3 removido da fila
Elemento 9 adicionado à fila
Frente da fila: 12 Traseira da fila: 9
BlockingQueue em Java
Tipos de BlockingQueue
Fila limitada
Fila sem limites
perguntas frequentes
Conclusão
Leitura recomendada