📦 Arrays e ArrayList

Estruturas de Dados, Listas Dinâmicas e Collections Framework

1. O que são Arrays e ArrayList?

Arrays e ArrayList são estruturas de dados fundamentais em Java para armazenar coleções de elementos. Ambos permitem acessar elementos via índice, mas têm diferenças importantes.

Um Array é uma coleção de tamanho fixo, definido na criação. Um ArrayList é uma coleção de tamanho dinâmico, que cresce automaticamente.

Escolher a estrutura correta é fundamental para escrever código eficiente e mantível.

2. Comparação Rápida

Array

Tamanho: Fixo, definido na criação
Tipos: Primitivos e objetos
Desempenho: Muito rápido (O1)
Flexibilidade: Baixa
Redimensionamento: Manual

ArrayList

Tamanho: Dinâmico, cresce automaticamente
Tipos: Apenas objetos
Desempenho: Rápido, com sobrecarga mínima
Flexibilidade: Muito alta
Redimensionamento: Automático

3. Arrays em Java

Um array é uma coleção de elementos do mesmo tipo armazenados em posições contíguas de memória. O tamanho é definido na criação e não pode ser alterado.

Declaração e Inicialização:

java

// Declaração de array de inteiros
int[] numeros = new int[5];

// Declaração com inicialização
int[] pares = {2, 4, 6, 8, 10};

// Array de Strings
String[] nomes = new String[3];
nomes[0] = "Ana";
nomes[1] = "Bruno";
nomes[2] = "Carlos";

// Array de doubles
double[] notas = {7.5, 8.0, 9.5, 6.5};

// Acessar elementos
System.out.println(pares[0]);      // 2
System.out.println(nomes.length);  // 3

// Percorrer com for tradicional
for (int i = 0; i < pares.length; i++) {
    System.out.println(pares[i]);
}

// For-each
for (int num : pares) {
    System.out.println(num);
}

Operações com Arrays:

java

import java.util.Arrays;

int[] numeros = {5, 2, 8, 1, 9};

// Ordenar array
Arrays.sort(numeros);
System.out.println(Arrays.toString(numeros)); // [1, 2, 5, 8, 9]

// Buscar elemento (array deve estar ordenado)
int indice = Arrays.binarySearch(numeros, 5);

// Preencher array
Arrays.fill(numeros, 10);

// Copiar array
int[] copia = Arrays.copyOf(numeros, numeros.length);

// Copiar parte do array
int[] parte = Arrays.copyOfRange(numeros, 1, 4);

// Comparar arrays
int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
System.out.println(Arrays.equals(arr1, arr2)); // true

Arrays Multidimensionais:

java

// Array bidimensional (matriz)
int[][] matriz = new int[3][3];

// Inicializar matriz
int[][] tabuleiro = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// Acessar elementos
System.out.println(tabuleiro[0][0]); // 1
System.out.println(tabuleiro[1][2]); // 6

// Percorrer matriz
for (int i = 0; i < tabuleiro.length; i++) {
    for (int j = 0; j < tabuleiro[i].length; j++) {
        System.out.print(tabuleiro[i][j] + " ");
    }
    System.out.println();
}

4. ArrayList em Java

Um ArrayList é uma implementação de List da Collections Framework que funciona como um array dinâmico. Cresce e diminui automaticamente conforme você adiciona ou remove elementos.

Declaração e Inicialização:

java

import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;

// Declaração básica
ArrayList nomes = new ArrayList<>();

// Com capacidade inicial
ArrayList numeros = new ArrayList<>(10);

// Usando interface List (boa prática)
List frutas = new ArrayList<>();

// ArrayList com inicialização de valores
ArrayList cores = new ArrayList<>();
cores.add("Vermelho");
cores.add("Verde");
cores.add("Azul");

// Usando Arrays.asList para inicializar
List capitais = new ArrayList<>(
    Arrays.asList("Brasília", "Rio", "São Paulo")
);

Métodos Principais:

java

ArrayList tarefas = new ArrayList<>();

// ✅ ADD - Adicionar elemento
tarefas.add("Estudar Java");
tarefas.add("Fazer exercícios");
tarefas.add(1, "Revisar POO");  // Inserir na posição 1

// ✅ GET - Obter elemento por índice
String primeira = tarefas.get(0);

// ✅ SET - Modificar elemento
tarefas.set(0, "Aprender ArrayList");

// ✅ REMOVE - Remover por índice
tarefas.remove(1);
// Remover por objeto
tarefas.remove("Fazer exercícios");

// ✅ SIZE - Obter tamanho
System.out.println(tarefas.size());

// ✅ CONTAINS - Verificar se contém
if (tarefas.contains("Aprender ArrayList")) {
    System.out.println("Encontrado!");
}

// ✅ INDEXOF - Encontrar índice
int indice = tarefas.indexOf("Aprender ArrayList");

// ✅ ISEMPTY - Verificar se está vazio
System.out.println(tarefas.isEmpty());

// ✅ CLEAR - Limpar lista
tarefas.clear();

// ✅ ADDALL - Adicionar múltiplos elementos
tarefas.addAll(Arrays.asList("Ler", "Escrever", "Pensar"));

Iteração sobre ArrayList:

java

ArrayList linguagens = new ArrayList<>(
    Arrays.asList("Java", "Python", "JavaScript", "C++")
);

// 1️⃣ For tradicional
for (int i = 0; i < linguagens.size(); i++) {
    System.out.println(linguagens.get(i));
}

// 2️⃣ For-each
for (String lang : linguagens) {
    System.out.println(lang);
}

// 3️⃣ Iterator
import java.util.Iterator;
Iterator iterator = linguagens.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

// 4️⃣ forEach com lambda (Java 8+)
linguagens.forEach(lang -> System.out.println(lang));

// 5️⃣ Stream API (Java 8+)
linguagens.stream()
    .forEach(System.out::println);

Ordenação e Busca:

java

import java.util.Collections;

ArrayList numeros = new ArrayList<>(
    Arrays.asList(5, 2, 8, 1, 9, 3)
);

// Ordenar em ordem crescente
Collections.sort(numeros);

// Ordenar em ordem decrescente
Collections.sort(numeros, Collections.reverseOrder());

// Encontrar máximo
int maximo = Collections.max(numeros);

// Encontrar mínimo
int minimo = Collections.min(numeros);

// Embaralhar
Collections.shuffle(numeros);

// Busca binária (lista deve estar ordenada)
Collections.sort(numeros);
int indice = Collections.binarySearch(numeros, 5);

// Inverter ordem
Collections.reverse(numeros);

5. Exemplo Prático: Sistema de Alunos

java

import java.util.ArrayList;
import java.util.Collections;

public class Aluno {
    private String nome;
    private double media;
    
    public Aluno(String nome, double media) {
        this.nome = nome;
        this.media = media;
    }
    
    public String getNome() { return nome; }
    public double getMedia() { return media; }
    
    @Override
    public String toString() {
        return nome + " - Média: " + media;
    }
}

public class SistemaAlunos {
    private ArrayList alunos;
    
    public SistemaAlunos() {
        alunos = new ArrayList<>();
    }
    
    public void adicionarAluno(String nome, double media) {
        alunos.add(new Aluno(nome, media));
    }
    
    public void listarAlunos() {
        for (Aluno a : alunos) {
            System.out.println(a);
        }
    }
    
    public void removerAluno(String nome) {
        alunos.removeIf(a -> a.getNome().equals(nome));
    }
    
    public int getTotalAlunos() {
        return alunos.size();
    }
}

// Uso
public class Main {
    public static void main(String[] args) {
        SistemaAlunos sistema = new SistemaAlunos();
        
        sistema.adicionarAluno("Ana", 8.5);
        sistema.adicionarAluno("Bruno", 7.0);
        sistema.adicionarAluno("Carlos", 9.5);
        
        System.out.println("Total: " + sistema.getTotalAlunos());
        sistema.listarAlunos();
    }
}

6. Quando Usar Array vs ArrayList?

✓ Use Array quando:

Conhece o tamanho exato dos dados
Precisa armazenar tipos primitivos
Máximo desempenho é crítico
Trabalha com matrizes multidimensionais
O tamanho nunca muda durante execução

✓ Use ArrayList quando:

O tamanho é desconhecido ou variável
Adiciona/remove elementos frequentemente
Quer usar métodos prontos (sort, contains, etc)
Trabalha com Collections Framework
Flexibilidade é mais importante que desempenho

7. Exercícios Práticos

Exercício 1: Calculadora de Notas

Use ArrayList para armazenar notas de alunos. Calcule média, maior nota, menor nota e quantos alunos passaram (média ≥ 6).

Exercício 2: Gerenciador de Produtos

Crie um sistema que use ArrayList para adicionar, remover e listar produtos. Implemente busca por nome e ordenação por preço.

Exercício 3: Manipulação de Arrays

Crie um programa que trabalhe com array de inteiros: ordenação, busca, inversão e cálculo de soma/média.

Exercício 4: Lista de Tarefas

Implemente um sistema de tarefas com ArrayList. Funcionalidades: adicionar, remover, marcar como concluída e listar.

Conclusão

Arrays e ArrayList são estruturas fundamentais para armazenar e manipular coleções de dados em Java.

Escolha a estrutura certa depende do seu caso de uso:

Arrays para dados fixos e desempenho crítico
ArrayList para flexibilidade e facilidade de manipulação

Para a maioria dos novos projetos, ArrayList é a melhor escolha. Arrays apenas para otimizações específicas.

Domine essas estruturas e você estará pronto para trabalhar com Collections mais avançadas! 🎓