Fila Java – Fila em Java

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

Fila Java

Nesta seção, discutiremos alguns pontos importantes sobre a Fila Java:

• 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 First In First Out.
• 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 qualquer operação relacionada a nulos, ele 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 thread-safe.
• ConcurrentLinkedQueue é uma fila thread-safe ilimitada baseada em nós ligados.
• 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 Fila Java

A interface Java Queue estende a interface Collection. A interface Collection estende a interface Iterable. Algumas das classes de implementação de fila frequentemente usadas 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 Fila Java

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 true se este conjunto contiver o elemento especificado.
4. Iterator iterator(): Retorna um iterador sobre os elementos deste conjunto. Os elementos são retornados sem uma ordem particular.
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): Mantém apenas os elementos neste 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 true ao ter sucesso e lançando uma IllegalStateException se nenhum espaço estiver atualmente disponível.
14. Object[] toArray(): Retorna um array contendo todos os elementos deste conjunto. Se este conjunto fizer alguma garantia sobre a ordem em que seus elementos são retornados pelo seu iterador, este método deve retornar os elementos na mesma ordem.

Conceitos Básicos de Fila em Java

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

Java Array para Fila

Aqui podemos explorar como converter uma matriz Java em uma 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, obtemos a seguinte saída:

[one, two, three, four, five]

Fila Java para Matriz

Aqui exploraremos como converter uma Fila Java em uma Matriz 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, obtemos a seguinte saída:

[one, two, three, four, five]

Operações Comuns de Fila em 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 todas as operações comuns de fila brevemente.

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

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

Nesta seção, discutiremos sobre a operação de inserção de fila em Java em detalhes 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 em duas formas:

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

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

Operação add() da Fila

A operação add() é usada para inserir um novo elemento na fila. Se ela executar a operação de inserção com sucesso, ela retorna o valor “true”. Caso contrário, ela 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, quando tentamos adicionar um 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 executada com sucesso, ela retornará o valor “true”. Caso contrário, retornará 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, quando tentamos adicionar um terceiro elemento usando a operação BlockingQueue.offer(), ela retorna o valor “false” como mostrado acima.

Operações de exclusão de fila em Java

Nesta seção, discutiremos sobre a operação de exclusão de fila em Java em detalhes com alguns exemplos úteis. As operações de exclusão retornam o elemento da cabeça da fila, se executarem com sucesso. Como sabemos, a fila suporta a operação de exclusão em duas formas:

• Fila.remove():
  Ele lança uma exceção se a operação falhar.- Fila.poll():
  Ele 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 a operação de exclusão for realizada 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 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());		
   }
}

Resultado:- Quando executamos o programa acima, obtemos a seguinte saída:

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

Como nossa fila tem apenas dois elementos, quando tentamos 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 a operação de exclusão for realizada com sucesso, ela 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 a operação de exclusão for realizada com sucesso, ela 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:- Ao executar o programa acima, obteremos a seguinte saída:

[one, two]
one
two
null

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

Operações de Exame da Fila em Java

Nesta seção, discutiremos as operações de exame da fila em Java com alguns exemplos úteis. Se essa operação for executada com sucesso, ela retornará o elemento da cabeça da fila sem removê-lo. Como sabemos, a fila suporta operações de exame de duas formas:

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

NOTA:- Esse 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 retornará o elemento da cabeça da fila. Caso contrário, ela lançará 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:- Ao executar 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ça 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 a operação de exame for bem-sucedida, ela retorna o elemento do início da fila. Caso contrário, retorna 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:- Quando executamos o programa acima, obtemos a seguinte saída:

one
[one]
null

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

Categorias de Filas 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 são limitadas por capacidade, o que significa que precisamos fornecer o tamanho máximo da fila no momento da criação. Por exemplo, ArrayBlockingQueue (veja exemplo anterior). Filas Ilimitadas são filas que NÃO são limitadas por capacidade, o que significa que não devemos fornecer o tamanho da fila. Por exemplo, LinkedList (veja exemplo anterior). 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. De outra forma, podemos classificá-las amplamente nos seguintes dois tipos:

• Filas Bloqueantes
• Filas Não-Bloqueantes

Todas as filas que implementam a interface BlockingQueue são Filas Bloqueantes e o restante são Filas Não-Bloqueantes. Filas Bloqueantes são bloqueadas até que terminem seu trabalho ou expire o tempo, mas Filas Não-Bloqueantes não são. Algumas filas são Deques e algumas filas são PriorityQueues.

Operações de Fila Bloqueante

Além das duas formas de operações da Fila, a BlockingQueue suporta mais duas formas, como mostrado abaixo.

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