Fila Java – Fila em Java

Fila Java

Na java.util package, a interface Java Queue está disponível e estende a interface java.util.Collection. Assim como a Lista Java, a Fila Java é uma coleção de elementos ordenados (ou objetos), mas ela realiza operações de inserção e remoção de maneira diferente. Podemos usar a Fila para armazenar elementos antes de processá-los.

• A interface java.util.Queue é um subtipo da interface java.util.Collection.
• Assim como uma fila do mundo real (por exemplo, em um banco ou em um caixa eletrônico), a Fila insere elementos no final e remove do início.
• A Fila Java representa uma lista ordenada de elementos.
• A Fila Java segue a ordem FIFO para inserir e remover seus elementos. FIFO significa Primeiro a Entrar, Primeiro a Sair.
• A Fila Java suporta todos os métodos da interface Collection.
• As implementações de Fila mais frequentemente usadas são LinkedList, ArrayBlockingQueue e PriorityQueue.
• BlockingQueues não aceitam elementos nulos. Se realizarmos alguma operação relacionada a nulos, ela lançará NullPointerException.
• BlockingQueues são usadas para implementar aplicativos baseados em Produtor/Consumidor.
• BlockingQueues são seguras para threads.
• Todas as Filas disponíveis no pacote java.util são Filas Ilimitadas e as Filas disponíveis no pacote java.util.concurrent são Filas Limitadas.
• Todas as Deques não são seguras para threads.
• ConcurrentLinkedQueue é uma Fila sem limite segura para threads baseada em nós encadeados.
• Todas as Filas suportam inserção na cauda da fila e remoção na cabeça da fila, exceto Deques.
• Deques são filas, mas suportam inserção e remoção de elementos em ambas as extremidades.

Diagrama de Classe da Classe Java Queue

A interface Java Queue estende a interface Collection. A interface Collection estende a interface Iterable. Alguns exemplos de implementações de classes de Fila frequentemente utilizadas são LinkedList, PriorityQueue, ArrayBlockingQueue, DelayQueue, LinkedBlockingQueue, PriorityBlockingQueue etc… AbstractQueue fornece uma implementação esquelética da interface Queue para reduzir o esforço na implementação da Fila.

Métodos da Classe Java Queue

Nesta seção, discutiremos alguns dos métodos úteis e frequentemente utilizados da Fila Java:

1. int size(): para obter o número de elementos no conjunto.
2. boolean isEmpty(): para verificar se o conjunto está vazio ou não.
3. boolean contains(Object o): Retorna verdadeiro se este conjunto contiver o elemento especificado.
4. Iterator iterator(): Retorna um iterador sobre os elementos deste conjunto. Os elementos são retornados sem nenhuma ordem específica.
5. boolean removeAll(Collection c): Remove deste conjunto todos os seus elementos que estão contidos na coleção especificada (operação opcional).
6. boolean retainAll(Collection c): Retém apenas os elementos deste conjunto que estão contidos na coleção especificada (operação opcional).
7. void clear(): Remove todos os elementos do conjunto.
8. E remove(): Retrieves and removes the head of this queue.
9. E poll(): Retrieves and removes the head of this queue, or returns null if this queue is empty.
10. E peek(): Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty.
11. boolean offer(E e): Insere o elemento especificado nesta fila, se for possível fazê-lo imediatamente sem violar as restrições de capacidade.
12. E element(): Retrieves, but does not remove, the head of this queue.
13. boolean add(E e): Insere o elemento especificado nesta fila, se for possível fazê-lo imediatamente sem violar as restrições de capacidade, retornando verdadeiro em caso de sucesso e lançando um IllegalStateException se não houver espaço disponível no momento.
14. Object[] toArray(): Retorna um array contendo todos os elementos deste conjunto. Se este conjunto garantir alguma ordem em que seus elementos são retornados pelo iterador, este método deve retornar os elementos na mesma ordem.

Java Queue Basics

Como a fila Java estende a coleção Java, ela também suporta todas as operações da interface Collection. Vamos explorar algumas operações simples no exemplo a seguir:

package com.journaldev.queue;
import java.util.*;

public class QueueExample {
   public static void main(String[] args) {
		
	Queue queue = new LinkedList<>();
	queue.add("one");
	queue.add("two");
	queue.add("three");
	queue.add("four");
	System.out.println(queue);
		
	queue.remove("three");
	System.out.println(queue);
	System.out.println("Queue Size: " + queue.size());
	System.out.println("Queue Contains element 'two' or not? : " + queue.contains("two"));

	 // Para esvaziar a fila
	queue.clear();
   }
}

Saída:-

[one, two, three, four]
[one, two, four]
Queue Size: 3
Queue Contains element 'two' or not? : true

Array Java para Fila

Aqui podemos explorar como converter um array Java em fila usando o método “Collections.addAll()” com um exemplo simples.

import java.util.*;

public class ArrayToQueue {
    public static void main(String[] args) {
		
	String nums[] = {"one","two","three","four","five"};
	Queue<String> queue = new LinkedList<>();
	Collections.addAll(queue, nums);
	System.out.println(queue);
   }
}

Saída:- Quando executamos o programa acima, obteremos a seguinte saída:

[one, two, three, four, five]

Fila Java para Array

Aqui vamos explorar como converter uma fila Java em um array Java usando “toArray()” com um exemplo simples.

import java.util.*;

public class QueueToArray {
   public static void main(String[] args) {
		
	Queue<String> queue = new LinkedList<>();
	queue.add("one");
	queue.add("two");
	queue.add("three");
	queue.add("four");
	queue.add("five");
		
	String strArray[] = queue.toArray(new String[queue.size()]);
	System.out.println(Arrays.toString(strArray)); 

   }
}

Saída:- Quando executamos o programa acima, obteremos a seguinte saída:

[one, two, three, four, five]

Operações Comuns de Fila Java

A fila Java suporta todas as operações suportadas pela interface Collection e algumas operações adicionais. Ela suporta quase todas as operações em duas formas.

• Um conjunto de operações lança uma exceção se a operação falhar.
• O outro conjunto de operações retorna um valor especial se a operação falhar.

A tabela a seguir explica brevemente todas as operações comuns de uma fila.

Vamos abordar cada operação e discuti-las detalhadamente com alguns exemplos úteis nas próximas seções.

Operações de Inserção na Fila em Java

Nesta seção, discutiremos a operação de inserção na fila em Java detalhadamente com alguns exemplos úteis. Se esta operação for bem-sucedida, ela retorna o valor “true”. Como sabemos, a fila suporta a operação de inserção de duas formas:

• Queue.add(e):
  Ela lança uma exceção se a operação falhar.- Queue.offer(e):
  Retorna um valor especial se a operação falhar.

OBSERVAÇÃO:- Este valor especial pode ser “false” ou “null”

Operação add() na Fila

A operação add() é usada para inserir um novo elemento na fila. Se ela realizar a operação de inserção com sucesso, retorna o valor “true”. Caso contrário, lança java.lang.IllegalStateException. Vamos desenvolver um exemplo simples para demonstrar essa funcionalidade.

import java.util.concurrent.*;

public class QueueAddOperation {
   public static void main(String[] args) {
		
	BlockingQueue<String> queue = new ArrayBlockingQueue<>(2);

	System.out.println(queue.add("one"));
	System.out.println(queue.add("two"));
	System.out.println(queue);
	System.out.println(queue.add("three"));
	System.out.println(queue);
   }
}

Saída:- Quando executamos o programa acima, obteremos a seguinte saída:

true
true
[one, two]
Exception in thread "main" java.lang.IllegalStateException: Queue full

Como nossa fila é limitada a dois elementos, ao tentarmos adicionar o terceiro elemento usando BlockingQueue.add(), ele lança uma exceção como mostrado acima.

Operação offer() da fila

A operação offer() é usada para inserir um novo elemento na fila. Se a operação de inserção for bem-sucedida, ela retorna o valor “true”. Caso contrário, retorna o valor “false”. Vamos desenvolver um exemplo simples para demonstrar essa funcionalidade.

import java.util.concurrent.*;

public class QueueOfferOperation {
   public static void main(String[] args) {
		
	BlockingQueue<String> queue = new ArrayBlockingQueue<>(2);

	System.out.println(queue.offer("one"));
	System.out.println(queue.offer("two"));
	System.out.println(queue);
	System.out.println(queue.offer("three"));
	System.out.println(queue);
   }
}

Saída:- Quando executamos o programa acima, obteremos a seguinte saída:

true
true
[one, two]
false
[one, two]

Como nossa fila é limitada a dois elementos, ao tentarmos adicionar o terceiro elemento usando a operação BlockingQueue.offer(), ela retorna o valor “false” como mostrado acima.

Operações de Exclusão na Fila Java

Nesta seção, discutiremos detalhadamente as operações de exclusão na fila Java com alguns exemplos úteis. As operações de exclusão retornam o elemento da cabeça da fila, se forem bem-sucedidas. Como sabemos, a fila suporta operações de exclusão em duas formas:

• Queue.remove():
  Ele lança uma exceção se a operação falhar.- Queue.poll():
  Retorna um valor especial se a operação falhar.

NOTA:- Aqui, o valor especial pode ser “false” ou “null”

Operação de remoção da fila

A operação remove() é usada para excluir um elemento da cabeça da fila. Se ela executar a operação de exclusão com sucesso, retorna o elemento da cabeça da fila. Caso contrário, lança java.util.NoSuchElementException. Vamos desenvolver um exemplo simples para demonstrar essa funcionalidade.

import java.util.*;

public class QueueRemoveOperation 
{
   public static void main(String[] args) 
   {		
	Queue<String> queue = new LinkedList<>();
	queue.offer("one");
	queue.offer("two");		
	System.out.println(queue);		
	System.out.println(queue.remove());
	System.out.println(queue.remove());		
	System.out.println(queue.remove());		
   }
}

Saída:- Ao executarmos o programa acima, obteremos a seguinte saída:

[one, two]
one
two
Exception in thread "main" java.util.NoSuchElementException

Como nossa fila possui apenas dois elementos, ao tentarmos chamar o método remove() pela terceira vez, ele lança uma exceção conforme mostrado acima. NOTA:- Queue.remove(element) é usado para excluir um elemento especificado da fila. Se ele executar a operação de exclusão com sucesso, retorna o valor “true”. Caso contrário, retorna o valor “false”.

Operação de sondagem da fila

A operação poll() é usada para excluir um elemento da cabeça da fila. Se ela executar a operação de exclusão com sucesso, retorna o elemento da cabeça da fila. Caso contrário, retorna o valor “null”. Vamos desenvolver um exemplo simples para demonstrar essa funcionalidade.

import java.util.*;

public class QueuePollOperation 
{
   public static void main(String[] args) 
   {		
	Queue<String> queue = new LinkedList<>();
	queue.offer("one");
	queue.offer("two");		
	System.out.println(queue);		
	System.out.println(queue.poll());
	System.out.println(queue.poll());		
	System.out.println(queue.poll());		
   }
}

Saída:- Quando executamos o programa acima, obteremos a seguinte saída:

[one, two]
one
two
null

Como nossa fila tem apenas dois elementos, quando tentamos chamar o método poll() pela terceira vez, ele retorna o valor nulo conforme mostrado acima.

Operações de Exame da Fila Java

Nesta seção, discutiremos sobre as operações de exame da fila Java em detalhes com alguns exemplos úteis. Se esta operação for bem-sucedida, ela retorna o elemento da cabeça da fila sem removê-lo. Como sabemos, a fila suporta operações de exame em duas formas:

• Queue.element():
  Lança uma exceção se a operação falhar.- Queue.peek():
  Retorna um valor especial se a operação falhar.

OBSERVAÇÃO:- Aqui, o valor especial pode ser “false” ou “null”

Operação element() da Fila

A operação element() é usada para recuperar um elemento da cabeça da fila, sem removê-lo. Se ela executar a operação de exame com sucesso, ela retorna o elemento da cabeça da fila. Caso contrário, ela lança java.util.NoSuchElementException. Vamos desenvolver um exemplo simples para demonstrar essa funcionalidade.

import java.util.*;

public class QueueElementOperation {
   public static void main(String[] args) {
		
	Queue<String> queue = new LinkedList<>();
	queue.add("one");
		
	System.out.println(queue.element());
	System.out.println(queue);
	queue.clear();
	System.out.println(queue.element());
   }
}

Saída:- Quando executamos o programa acima, obteremos a seguinte saída:

one
[one]
Exception in thread "main" java.util.NoSuchElementException

Se tentarmos chamar o método element() em uma fila vazia, ele lançará uma exceção como mostrado acima.

Operação peek() da fila

A operação peek() é usada para recuperar um elemento do início da fila, sem removê-lo. Se ela realizar a operação de exame com sucesso, retornará o elemento do início da fila. Caso contrário, retornará o valor nulo. Vamos desenvolver um exemplo simples para demonstrar essa funcionalidade.

import java.util.*;

public class QueuePeekOperation {
   public static void main(String[] args) {
		
	Queue<String> queue = new LinkedList<>();
	queue.add("one");
		
	System.out.println(queue.peek());
	System.out.println(queue);
	queue.clear();
	System.out.println(queue.peek());
   }
}

Saída:-Ao executarmos o programa acima, obteremos a seguinte saída:

one
[one]
null

Se tentarmos chamar o método peek() em uma fila vazia, ele retornará o valor nulo, mas NÃO lançará uma exceção como mostrado acima.

Categorias de Fila em Java

No Java, podemos encontrar muitas implementações de filas. Podemos categorizá-las amplamente nos seguintes dois tipos:

• Filas Limitadas
• Filas Ilimitadas

Filas Limitadas são filas que têm uma capacidade limitada, o que significa que precisamos fornecer o tamanho máximo da fila no momento da criação. Por exemplo, ArrayBlockingQueue (veja o exemplo anterior). Filas Ilimitadas são filas que NÃO têm capacidade limitada, o que significa que não devemos fornecer o tamanho da fila. Por exemplo, LinkedList (veja o exemplo anterior). Todas as Filas disponíveis no pacote java.util são Filas Ilimitadas e Filas disponíveis no pacote java.util.concurrent são Filas Limitadas. De outras formas, podemos categorizá-las amplamente nos seguintes dois tipos:

• Filas de Bloqueio
• Filas Não de Bloqueio

Todas as Filas que implementam a interface BlockingQueue são Filas de Bloqueio e o restante são Filas Não de Bloqueio. Filas de Bloqueio bloqueiam até que concluam seu trabalho ou ocorra um tempo limite, mas Filas Não de Bloqueio não bloqueiam. Algumas Filas são Deques e algumas são PriorityQueues.

Operações de Fila de Bloqueio

Além das duas formas de operações da Fila, as BlockingQueues suportam mais duas formas, como mostrado abaixo.

Algumas operações são bloqueadas até que concluam seu trabalho e outras são bloqueadas até ocorrer um tempo limite. Isso é tudo para um resumo rápido sobre Filas em Java. Espero que esses exemplos de Filas em Java ajudem você a começar a programar com coleções de Filas. Por favor, deixe-me um comentário se você gostou dos meus tutoriais ou tem alguma sugestão, problema ou erro de digitação. Obrigado.