Java Essencial: Arrays e algoritmos básicos de manipulação

O que é um array em Java

Um array é uma estrutura que armazena uma sequência de elementos do mesmo tipo, com tamanho fixo definido na criação. Em Java, arrays são objetos: você cria, guarda uma referência e acessa elementos por índice (base 0).

Características importantes

• Índices: vão de 0 até length - 1.
• Tamanho fixo: não cresce automaticamente; para “aumentar”, você cria outro array e copia.
• Validação automática: acesso fora do intervalo lança ArrayIndexOutOfBoundsException.
• Campo length: o tamanho do array é obtido por array.length (sem parênteses).

Declaração, inicialização e acesso por índice

Declaração e criação com tamanho

int[] notas = new int[5]; // 5 posições, valores padrão (0)

Ao criar um array numérico, as posições começam com 0. Para boolean, o padrão é false. Para referências (ex.: String[]), o padrão é null.

Inicialização literal

int[] idades = { 18, 21, 30, 25 };

Acesso e atualização por índice

int primeira = idades[0];     // 18 (primeiro elemento)idades[2] = 31;             // altera o terceiro elemento

Usando length com segurança

int ultimoIndice = idades.length - 1;int ultimaIdade = idades[ultimoIndice];

Evite “números mágicos” (como 3 ou 10) para limites; use sempre length.

Arrays multidimensionais (matrizes)

Um array multidimensional em Java é, na prática, um array de arrays. O caso mais comum é o 2D, usado como matriz (linhas e colunas).

Criação de uma matriz retangular

int[][] tabela = new int[3][4]; // 3 linhas, 4 colunas

Inicialização literal

int[][] vendas = {  { 10, 12, 9 },  { 7,  14, 8 },  { 11, 10, 13 }};

Acesso por linha e coluna

int valor = vendas[1][2]; // linha 1, coluna 2 (8)vendas[0][0] = 15;

Matrizes irregulares (jagged)

Como é um array de arrays, cada linha pode ter tamanho diferente.

Continue em nosso aplicativo e ...

• Ouça o áudio com a tela desligada
• Ganhe Certificado após a conclusão
• + de 5000 cursos para você explorar!

ou continue lendo abaixo...

Baixar o aplicativo

int[][] irregular = new int[3][];irregular[0] = new int[2];irregular[1] = new int[5];irregular[2] = new int[1];

Ao trabalhar com 2D, valide sempre matriz.length (linhas) e matriz[i].length (colunas da linha i).

Cópia e redimensionamento

Como arrays têm tamanho fixo, “redimensionar” significa criar um novo array e copiar os elementos.

Cópia com System.arraycopy (passo a passo)

Use quando você quer copiar um intervalo específico com boa performance.

1. Crie o array de destino com o tamanho desejado.
2. Chame System.arraycopy informando origem, índices e quantidade.

int[] origem = { 5, 8, 2, 9, 1 };int[] destino = new int[origem.length];System.arraycopy(origem, 0, destino, 0, origem.length);

Assinatura: System.arraycopy(src, srcPos, dest, destPos, length).

Cópia/redimensionamento com Arrays.copyOf

Útil para criar uma cópia completa ou aumentar/diminuir o tamanho.

import java.util.Arrays;int[] base = { 1, 2, 3 };int[] maior = Arrays.copyOf(base, 5); // [1,2,3,0,0]int[] menor = Arrays.copyOf(base, 2); // [1,2]

Se o novo tamanho for maior, as posições extras recebem o valor padrão do tipo.

Utilitários essenciais da classe Arrays

Arrays.toString (visualização rápida)

import java.util.Arrays;int[] a = { 3, 1, 4 };System.out.println(Arrays.toString(a)); // [3, 1, 4]

Para 2D, prefira Arrays.deepToString.

int[][] m = { {1,2}, {3,4} };System.out.println(Arrays.deepToString(m)); // [[1, 2], [3, 4]]

Arrays.sort (ordenação)

import java.util.Arrays;int[] a = { 3, 1, 4, 2 };Arrays.sort(a);System.out.println(Arrays.toString(a)); // [1, 2, 3, 4]

Arrays.sort ordena em ordem crescente. Para tipos primitivos, usa algoritmos otimizados; para objetos, usa comparações.

Algoritmos básicos de manipulação (na prática)

A seguir, algoritmos simples e frequentes para trabalhar com arrays. Os exemplos assumem arrays de int, mas a ideia se aplica a outros tipos.

Busca linear (encontrar um valor)

Varre o array do início ao fim até encontrar o alvo. Retorna o índice ou -1 se não existir.

static int buscaLinear(int[] a, int alvo) {  for (int i = 0; i < a.length; i++) {    if (a[i] == alvo) return i;  }  return -1;}

Soma e média

Para média, cuidado com divisão inteira: use double.

static int soma(int[] a) {  int s = 0;  for (int v : a) s += v;  return s;}static double media(int[] a) {  if (a.length == 0) return 0.0;  return (double) soma(a) / a.length;}

Mínimo e máximo

Valide array vazio antes de acessar a[0].

static int minimo(int[] a) {  if (a.length == 0) throw new IllegalArgumentException("array vazio");  int min = a[0];  for (int i = 1; i < a.length; i++) {    if (a[i] < min) min = a[i];  }  return min;}static int maximo(int[] a) {  if (a.length == 0) throw new IllegalArgumentException("array vazio");  int max = a[0];  for (int i = 1; i < a.length; i++) {    if (a[i] > max) max = a[i];  }  return max;}

Remoção lógica (marcar como removido)

Como o array não encolhe, uma estratégia é manter um tamanho lógico (n) menor que length. Remover significa “desconsiderar” um elemento e ajustar n.

Exemplo: remover o elemento na posição idx deslocando os próximos para a esquerda e decrementando n.

static int removerPorIndice(int[] a, int n, int idx) {  if (idx < 0 || idx >= n) throw new IndexOutOfBoundsException();  for (int i = idx; i < n - 1; i++) {    a[i] = a[i + 1];  }  // opcional: limpar a última posição lógica antiga  a[n - 1] = 0;  return n - 1;}

Neste padrão, n representa quantos elementos são válidos. As posições de n até a.length - 1 são “lixo”/reserva.

Compactação (remover “buracos”)

Quando você usa um valor sentinela (por exemplo, -1) para indicar removidos, pode compactar movendo apenas os válidos para o início.

static int compactarRemovidos(int[] a, int sentinela) {  int write = 0;  for (int read = 0; read < a.length; read++) {    if (a[read] != sentinela) {      a[write] = a[read];      write++;    }  }  // opcional: preencher o restante com sentinela  for (int i = write; i < a.length; i++) a[i] = sentinela;  return write; // novo tamanho lógico}

O retorno é o novo tamanho lógico (quantos elementos válidos restaram).

Exemplo guiado: dados tabulares com validação de limites

Imagine uma tabela simples de vendas (linhas = vendedores, colunas = meses). Você quer: somar por vendedor, achar o maior total e validar acessos.

Passo a passo

1. Defina a matriz com os dados.
2. Crie um array para totais por linha.
3. Some cada linha e armazene no array de totais.
4. Encontre o máximo no array de totais.
5. Crie uma função de leitura segura com validação de índices.

import java.util.Arrays;static int getSeguro(int[][] m, int lin, int col) {  if (lin < 0 || lin >= m.length) throw new IndexOutOfBoundsException("linha inválida");  if (col < 0 || col >= m[lin].length) throw new IndexOutOfBoundsException("coluna inválida");  return m[lin][col];}static int[] totaisPorVendedor(int[][] vendas) {  int[] totais = new int[vendas.length];  for (int i = 0; i < vendas.length; i++) {    int soma = 0;    for (int j = 0; j < vendas[i].length; j++) soma += vendas[i][j];    totais[i] = soma;  }  return totais;}static int indiceDoMaior(int[] a) {  if (a.length == 0) return -1;  int idx = 0;  for (int i = 1; i < a.length; i++) {    if (a[i] > a[idx]) idx = i;  }  return idx;}public static void main(String[] args) {  int[][] vendas = { { 10, 12, 9 }, { 7, 14, 8 }, { 11, 10, 13 } };  int[] totais = totaisPorVendedor(vendas);  System.out.println("Totais: " + Arrays.toString(totais));  int melhor = indiceDoMaior(totais);  System.out.println("Melhor vendedor (índice): " + melhor);  System.out.println("Leitura segura vendas[1][2]: " + getSeguro(vendas, 1, 2));}

Exercícios propostos (com dados tabulares e validação)

1) Boletim de notas (1D)

Dado um array de notas inteiras (0 a 100):

• Calcule soma, média (double), mínimo e máximo.
• Implemente buscaLinear para encontrar uma nota específica.
• Valide limites: se o array estiver vazio, trate adequadamente (ex.: exceção ou retorno padrão).

Dados para teste: {72, 85, 90, 60, 85, 100, 73}.

2) Remoção lógica e compactação (1D)

Você tem um array de códigos de produto e usa -1 como removido.

• Marque como removidos todos os códigos menores que 100 (substitua por -1).
• Compacte o array para mover os válidos para o início e obtenha o novo tamanho lógico.
• Imprima o array antes e depois com Arrays.toString.

Dados para teste: {150, 90, 220, 75, 180, 101}.

3) Tabela de temperaturas (2D)

Uma matriz int[][] representa temperaturas por cidade (linhas) e dias do mês (colunas).

• Crie uma função getSeguro para validar índices de linha e coluna.
• Calcule a média por cidade (um array double[]).
• Encontre a cidade com maior média.

Dados para teste (3 cidades x 5 dias): {{30,31,29,28,30},{25,26,27,26,25},{33,32,34,35,33}}.

4) Copiando e “aumentando” capacidade (1D)

Implemente uma rotina que simula aumento de capacidade:

• Comece com um array de capacidade 3 e tamanho lógico 0.
• Ao inserir um novo elemento, se o tamanho lógico atingir a capacidade, crie um novo array com o dobro do tamanho usando Arrays.copyOf.
• Insira 10 valores e imprima a capacidade final e o conteúdo válido.

5) Ordenação e busca (1D)

Dado um array de inteiros:

• Ordene com Arrays.sort.
• Depois da ordenação, faça uma busca linear para confirmar a presença de 3 valores (um existente, um repetido e um inexistente).
• Valide limites ao acessar o primeiro e o último elemento usando length.

Dados para teste: {9, 1, 5, 1, 7, 3, 8}.