1.1 O que é uma Fila?

A Fila (ou Queue) é uma estrutura de dados linear e restrita que opera sob a disciplina de acesso FIFO (First-In, First-Out) — o primeiro elemento a entrar na estrutura deve ser obrigatoriamente o primeiro a sair.

Diferente das pilhas (onde tudo ocorre no topo) ou de arrays comuns (onde qualquer índice pode ser acessado livremente), em uma fila as operações ocorrem em duas extremidades distintas: a inserção de novos dados é feita sempre no fim (ou traseira/rear) e a remoção ou consulta ocorre sempre no início (ou frente/front).

1.2 Analogias e Funcionamento

A analogia clássica mais intuitiva é a fila de atendimento de um banco: a primeira pessoa que chega é a primeira a ser atendida pelo caixa, enquanto as próximas pessoas aguardam ordenadamente no final da fila.

No ecossistema de software e na arquitetura de sistemas operacionais, esse padrão é essencial em:

• Fila de Impressão (Print Spooler): Garante que os documentos impressos por múltiplos usuários sejam processados estritamente na ordem em que foram enviados.
• Escalonamento de Processos no S.O. (Round-Robin / Ready Queue): O sistema operacional gerencia threads e processos prontos para execução em uma fila de espera da CPU.
• Mensageria e Buffers Assíncronos (RabbitMQ, Apache Kafka, Redis Queue): Permite a comunicação desacoplada entre microsserviços com garantia de processamento ordenado de mensagens.

2.1 O Modelo de Armazenamento Estático para Filas

Implementar uma fila utilizando vetores estáticos em Java oferece alto desempenho e controle de baixo nível sobre a memória, mas impõe um desafio geométrico peculiar:

2.2 Soluções Arquiteturais

3.1 O que é Overflow (Estouro)?

Em uma fila de capacidade fixa, o erro de Overflow ocorre quando solicitamos a inserção de um elemento (enfileirar) e a quantidade de dados armazenados já atingiu a capacidade limite da estrutura. Tentar escrever sem checagem causaria sobrescrita indevida ou exceção de índice fora dos limites (ArrayIndexOutOfBoundsException).

3.2 O que é Underflow (Esvaziamento)?

O erro de Underflow ocorre no sentido inverso: quando uma rotina solicita a remoção (desenfileirar) ou a consulta (espiarInicio) de um elemento em uma fila que se encontra completamente vazia (total == 0).

Dica de Projeto Defensivo

Em filas circulares, manter uma variável de controle explícita (ex: total de elementos) simplifica drasticamente as verificações de estado (vazia e cheia), eliminando a ambiguidade clássica onde inicio == fim pode significar tanto fila cheia quanto fila vazia.

Abaixo está a interface pública padronizada que garante o encapsulamento, robustez e alta coesão na manipulação da Fila Circular:

Abaixo apresentamos a classe FilaCircular.java com tratamento rigoroso contra Overflow e Underflow utilizando a aritmética modular para reaproveitamento total da memória alocada:

public class FilaCircular {
    private int inicio;     // Aponta para o elemento que está na frente da fila
    private int fim;        // Aponta para a próxima posição livre no fim da fila
    private int total;      // Controla a quantidade real de elementos presentes
    private int[] itens;    // Vetor que armazena os dados fisicamente

    // Construtor que inicializa a fila com capacidade estática
    public FilaCircular(int tamanho) {
        this.inicio = 0;
        this.fim = 0;
        this.total = 0;
        this.itens = new int[tamanho];
    }

    // Verifica se a fila está vazia
    public boolean verificarFilaVazia() {
        return this.total == 0;
    }

    // Verifica se a fila atingiu sua capacidade física limite
    public boolean verificarFilaCheia() {
        return this.total == this.itens.length;
    }

    // Adiciona um valor no fim da fila (ENQUEUE) com proteção contra Overflow
    public void enfileirar(int valor) {
        if (verificarFilaCheia()) {
            System.out.println("[Erro] Overflow! A fila está cheia. Não foi possível inserir: " + valor);
            return;
        }
        this.itens[this.fim] = valor;
        // Aritmética Modular: reinicia o índice para 0 ao ultrapassar o fim físico do array
        this.fim = (this.fim + 1) % this.itens.length; 
        this.total++;
        System.out.println("Inserido: " + valor + " | Total de elementos na Fila: " + this.total);
    }

    // Remove o elemento da frente da fila (DEQUEUE) com proteção contra Underflow
    public int desenfileirar() {
        if (verificarFilaVazia()) {
            throw new RuntimeException("[Erro] Underflow! A fila está vazia. Impossível remover.");
        }
        int valorRemovido = this.itens[this.inicio];
        // Avanço circular do ponteiro de início
        this.inicio = (this.inicio + 1) % this.itens.length;
        this.total--;
        System.out.println("Removido: " + valorRemovido + " | Total de elementos restantes: " + this.total);
        return valorRemovido;
    }

    // Consulta o elemento que está na frente (PEEK) sem alterá-lo
    public int espiarInicio() {
        if (verificarFilaVazia()) {
            throw new RuntimeException("A fila está vazia. Não há elementos para consultar.");
        }
        return this.itens[this.inicio];
    }

    // Retorna a quantidade atual de itens
    public int obterTotal() {
        return this.total;
    }
}

public class AppFila {
    public static void main(String[] args) {
        System.out.println("--- Execução da Fila Circular ---\n");

        // Instancia uma Fila Circular com capacidade para 3 elementos
        FilaCircular filaAtendimento = new FilaCircular(3);

        // 1. Enfileirando elementos até preencher
        filaAtendimento.enfileirar(101); // Senha 101
        filaAtendimento.enfileirar(102); // Senha 102
        filaAtendimento.enfileirar(103); // Senha 103

        // 2. Testando tentativa de estouro (Overflow)
        filaAtendimento.enfileirar(104); // Deve acusar fila cheia

        System.out.println("\nPróximo a ser atendido: " + filaAtendimento.espiarInicio());

        // 3. Atendendo clientes (Desenfileirando 2 posições)
        System.out.println("\n--- Atendimento no Caixa ---");
        filaAtendimento.desenfileirar(); // Remove 101
        filaAtendimento.desenfileirar(); // Remove 102

        // 4. Reaproveitamento Circular de Memória
        System.out.println("\n--- Testando Inserção Circular nos Espaços Liberados ---");
        filaAtendimento.enfileirar(104); // Inserido circularmente!
        filaAtendimento.enfileirar(105); // Inserido normalmente!

        // 5. Esvaziando totalmente a estrutura
        System.out.println("\n--- Descarregando o Restante da Fila ---");
        while (!filaAtendimento.verificarFilaVazia()) {
            filaAtendimento.desenfileirar();
        }
    }
}

Sintetize e consolide as distinções estruturais entre as duas principais estruturas de dados sequenciais lineares: