Você está aqui: Java ::: Estruturas de Dados ::: Filas

Como criar uma fila em Java usando um vetor de ints - Estruturas de Dados em Java

Quantidade de visualizações: 2258 vezes
A Fila é uma estrutura de dados do tipo FIFO - First-In, First-Out (Primeiro a entrar, primeiro a sair). Neste tipo de estrutura, o primeiro elemento a ser inserido é o primeiro a ser removido. Funciona exatamente igual a fila de um banco, fila para comprar ingressos, fila para pagar no caixa da lanchonete, etc.

Veja a imagem a seguir:



Embora seja mais comum a criação de uma estrutura de dados do tipo Fila de forma dinâmica (usando ponteiros e referências), nesta dica eu mostrarei como podemos criá-la em Java usando um array, ou seja, um vetor. No exemplo eu usei inteiros, mas você pode modificar para o tipo de dados que você achar mais adequado.

Veja o código completo para uma classe Fila usando um vetor de ints. Veja que o tamanho do vetor é informado no construtor da classe. Note também a lógica empregada na construção dos métodos enfileirar(), desenfileirar() e imprimirFila():

Código para Fila.java:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package estudos;

public class Fila {
  private int elementos[];
  private int inicio; // início da fila
  private int fim; // fim da fila
  private int maximo; // quantidade máxima de elementos na fila

  // construtor da Fila que aceita o tamanho
  public Fila(int tamanho) {
    // constrói o vetor com o tamanho informado
    this.elementos = new int[tamanho];
    this.inicio = 0; // define o início como sendo o primeiro elemento
    this.fim = -1; // fila vazia. Não tem final ainda
    this.maximo = tamanho; // ajusta a quantidade máxima de elementos
  }

  // método que permite enfileirar um novo elemento
  public void enfileirar(int item) {
    // a fila já está cheia
    if (this.fim == (this.maximo - 1)) {
      System.out.println("\nA fila está cheia.\n");
    } // ainda há espaço na fila
    else {
      this.elementos[++this.fim] = item;
    }
  }

  // método que permite desenfileirar e retornar
  // o elemento no início da fila
  public int desenfileirar() {
    // a fila está vazia
    if (this.inicio == (this.fim + 1)) {
      System.out.println("\nA fila está vazia.\n");
      return -1;
    } // retorna o elemento desenfileirado
    else {
      System.out.println("Elemento desenfileirado: "
        + this.elementos[this.inicio]);
      return this.elementos[this.inicio++];
    }
  }

  // exibe os elementos da fila
  public void exibirFila() {
    // a fila está vazia
    if (this.inicio == (this.fim + 1)) {
      System.out.println("\nA fila está vazia.\n");
    } 
    else {
      for (int i = this.inicio; i <= this.fim; i++) {
        System.out.println("Item[" + (i + 1) + "]: "
          + this.elementos[i]);
      }
    }
  }
}

Veja agora o código para a classe principal, ou seja, a classe Principal usada para testar a funcionalidade da nossa fila:

Código para Principal.java:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package estudos;

public class Estudos {

  public static void main(String[] args) {
    // Vamos criar uma nova fila com espaço para 5 elementos
    Fila fila = new Fila(5);

    // vamos inserir 3 elementos na fila
    fila.enfileirar(34);
    fila.enfileirar(27);
    fila.enfileirar(11);

    // vamos imprimir a fila
    System.out.println("\nOs itens na fila são: ");
    fila.exibirFila();

    // vamos desenfileirar dois itens
    System.out.println();
    fila.desenfileirar();
    fila.desenfileirar();

    // vamos imprimir a fila novamente
    System.out.println("\nOs itens na fila são: ");
    fila.exibirFila();
  }
}

Ao executar este código Java nós teremos o seguinte resultado:

Os itens na fila são:
Item[1]: 34
Item[2]: 27
Item[3]: 11

Elemento desenfileirado: 34
Elemento desenfileirado: 27

Os itens na fila são:
Item[3]: 11

Link para compartilhar na Internet ou com seus amigos:

Java ::: Desafios e Lista de Exercícios Resolvidos ::: Recursão (Recursividade)

Exercício Resolvido de Java - Um método recursivo que calcula o número de Fibonacci para um dado índice

Quantidade de visualizações: 6873 vezes
Pergunta/Tarefa:

Observe a série de números Fibonacci abaixo:

Série:  0  1  1  2  3  5  8  13  21  34  55  89 
Índice: 0  1  2  3  4  5  6   7   8   9  10  11 
Cada número da série é a soma dos dois números anteriores. A linha de baixo reflete o índice do número. Assim, quando falamos "O quinto número de Fibonacci", nós estamos nos referindo ao índice 4, ou seja, o valor 3.

Este algorítmos consiste em, dado um determinado índice, retornar o número de Fibonacci correspondente. Recursivamente, o cálculo pode ser feito da seguinte forma:

fib(0) = 0;
fib(1) = 1;
fib(indice) = fib(indice - 2) + fib(indice - 1); sendo o indice >= 2

Os casos nos quais os índices são 0 ou 1 são os casos bases (aqueles que indicam que a recursividade deve parar). Seu método deverá possuir a seguinte assinatura:

public static int fibonacci(int indice){
  // sua implementação aqui
}
Sua saída deverá ser parecida com:

Informe o índice: 6
O número de Fibonacci no índice informado é: 8
Resposta/Solução:

Veja a resolução comentada deste exercício usando Java console:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package estudos;

import java.util.Scanner;

public class Estudos {
  public static void main(String[] args) {
    // cria um novo objeto da classe Scanner
    Scanner entrada = new Scanner(System.in);
    
    // vamos solicitar o índice do número de Fibonacci
    System.out.print("Informe o índice: ");
    // lê o índice
    int indice = Integer.parseInt(entrada.nextLine());
    
    // calcula o número de Fibonacci no índice informado
    System.out.print("O número de Fibonacci no índice informado é: " +
      fibonacci(indice));
    System.out.println("\n");
  }
  
  // método recursivo que o número de Fibonacci em um determinado índice
  public static int fibonacci(int indice){
    if(indice == 0){ // caso base; interrompe a recursividade
      return 0;
    }
    else if(indice == 1){ // caso base; interrompe a recursividade
      return 1;
    }
    else{ // efetua uma nova chamada recursiva
      return fibonacci(indice - 1) + fibonacci(indice - 2);
    }
  }
}



Java ::: Classes e Componentes ::: JTree

Java Swing - Como obter o texto do ítem selecionado na JTree

Quantidade de visualizações: 11060 vezes
Nesta dica veremos como usar o método getLastSelectedPathComponent() da classe JTable do Java Swing para obter o texto do item (nó) selecionado na árvore. Veja como fazemos um cast (conversão) para um objeto da classe DefaultMutableTreeNode antes de podermos acessar o nó retornado.

O resultado será igual ao que temos na imagem abaixo:



Veja o código Java Swing completo para este exemplo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package arquivodecodigos;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.tree.*;
 
public class Estudos extends JFrame{
  JTree arvore;  
 
  public Estudos(){
    super("Exemplo de uma JTree simples");
     
    DefaultMutableTreeNode raiz = montarArvore();
    arvore = new JTree(raiz);  
 
    JButton btn = new JButton("Obter Texto");
    btn.addActionListener(
      new ActionListener(){
        @Override
        public void actionPerformed(ActionEvent e){
          if(!arvore.isSelectionEmpty()){
            DefaultMutableTreeNode no = (DefaultMutableTreeNode)
              arvore.getLastSelectedPathComponent();
 
            JOptionPane.showMessageDialog(null,
          "Texto do ítem selecionado: " + no.toString(), 
          "JTree", JOptionPane.INFORMATION_MESSAGE);
          }
        }
      }
    );
 
    Container c = getContentPane();
    c.setLayout(new FlowLayout());
             
    JScrollPane scrollPane = new JScrollPane(arvore);
    c.add(scrollPane);
    c.add(btn);
     
    setSize(400, 300);
    setVisible(true);
  }
     
  public static void main(String args[]){
    Estudos app = new Estudos();
    app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
 
  private DefaultMutableTreeNode montarArvore(){ 
    DefaultMutableTreeNode raiz = new DefaultMutableTreeNode("Cidades"); 
    DefaultMutableTreeNode regiao = new DefaultMutableTreeNode("Região"); 
    regiao.add(new DefaultMutableTreeNode("Centro-Oeste"));
    regiao.add(new DefaultMutableTreeNode("Norte"));
    regiao.add(new DefaultMutableTreeNode("Sul"));     
          
    raiz.add(regiao); 
    return raiz; 
  }
}



Java ::: Pacote java.lang ::: String

Java para iniciantes - Como usar o método replace() da classe String para efetuar a substituição de caracteres em uma string

Quantidade de visualizações: 9502 vezes
Em algumas situações gostaríamos de substituir caracteres (não substrings) em uma string. Isso pode ser feito por meio do método replace() da classe String. Veja sua assinatura:

public String replace(char oldChar, char newChar)
O parâmetro oldChar representa o caractere que será substituído pelo valor no parâmetro newChar. Note que todas as ocorrências de oldChar serão substituídas por newChar. O resultado será um novo objeto String com as substituições aplicadas. Se não houver substituições a string atual é retornada.

Veja um trecho de código no qual substituímos todas as letras "a" por "e" e retornamos uma nova string com as substituições:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

public class Estudos {
  public static void main(String[] args) {
    String frase = "Programar em Java é muito bom";
    System.out.println("Frase original: " + frase);
    
    // vamos substituir todas as letras "a" por "e"
    frase = frase.replace('a', 'e');
    System.out.println("Depois da substituição: " + frase);
  }
}

Após a execução deste código teremos o seguinte resultado:

Frase original: Programar em Java é muito bom
Depois da substituição: Progremer em Jeve é muito bom



Desafios, Exercícios e Algoritmos Resolvidos de Java

Veja mais Dicas e truques de Java

Dicas e truques de outras linguagens

Códigos Fonte

Programa de Gestão Financeira Controle de Contas a Pagar e a Receber com Cadastro de Clientes e FornecedoresSoftware de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimento
Diga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais
Controle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidadesControle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidades
Tenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: Delphi
6º lugar: C
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby



© 2025 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 38 usuários muito felizes estudando em nosso site.