Algoritmos e estruturas de dados em Java: guia prático

Algoritmos e estruturas de dados em Java: da teoria à prática

Compreender algoritmos e estruturas de dados é a base sobre a qual se constrói a carreira de qualquer desenvolvedor Java. Sem esse conhecimento, é difícil escrever código eficiente, escalável e de fácil manutenção. Neste artigo, abordaremos as principais estruturas de dados e algoritmos que você usará diariamente e mostraremos sua implementação em Java com exemplos práticos.

1. Estruturas de dados básicas no Java Collections Framework

O Java oferece um poderoso framework de coleções que inclui as principais estruturas de dados. Vamos analisar as três mais populares.

ArrayList — array dinâmico

ArrayList é uma implementação de array dinâmico. Ele se expande automaticamente ao adicionar novos elementos, tornando-se uma excelente escolha para listas cujo tamanho não é conhecido antecipadamente.

import java.util.ArrayList;

public class ArrayListExample {    public static void main(String[] args) {        ArrayList<String> fruits = new ArrayList<>();        fruits.add("Maçã");        fruits.add("Banana");        fruits.add("Laranja");

        System.out.println("Segundo elemento: " + fruits.get(1)); // Banana        fruits.remove(0);        System.out.println("Tamanho após remoção: " + fruits.size()); // 2                for (String fruit : fruits) {            System.out.println(fruit);        }    }}

Complexidade das operações: acesso por índice — O(1), inserção/remoção no meio — O(n).

HashMap — tabela hash

HashMap armazena pares «chave-valor» e fornece acesso praticamente instantâneo aos dados pela chave.

import java.util.HashMap;

public class HashMapExample {    public static void main(String[] args) {        HashMap<String, Integer> ages = new HashMap<>();        ages.put("Ana", 25);        ages.put("João", 30);        ages.put("Maria", 28);

        System.out.println("Idade da Ana: " + ages.get("Ana")); // 25                // Verificação de existência da chave        if (ages.containsKey("João")) {            System.out.println("João encontrado!");        }                // Iteração sobre todas as entradas        for (String name : ages.keySet()) {            System.out.println(name + ": " + ages.get(name) + " anos");        }    }}

Complexidade das operações: inserção, busca, remoção — em média O(1).

LinkedList — lista duplamente encadeada

LinkedList é composta por nós, cada um armazenando referências ao elemento anterior e ao próximo. Ideal para inserções e remoções frequentes no início ou no final da lista.

import java.util.LinkedList;

public class LinkedListExample {    public static void main(String[] args) {        LinkedList<Integer> queue = new LinkedList<>();                // Usando como fila (FIFO)        queue.addLast(1);        queue.addLast(2);        queue.addLast(3);                System.out.println("Primeiro da fila: " + queue.getFirst()); // 1        queue.removeFirst();        System.out.println("Após remoção: " + queue); // [2, 3]                // Usando como pilha (LIFO)        queue.push(10); // adiciona no início        queue.push(20);        System.out.println("Topo da pilha: " + queue.pop()); // 20    }}

Complexidade das operações: inserção/remoção no início/fim — O(1), acesso por índice — O(n).

2. Algoritmos de ordenação em Java

Ordenação é uma das tarefas mais comuns. Vamos analisar duas implementações clássicas.

Ordenação bolha (Bubble Sort)

Algoritmo simples, mas lento. Usado para fins educacionais.

public class BubbleSort {    public static void bubbleSort(int[] arr) {        int n = arr.length;        boolean swapped;                for (i