Percorrendo Arrays em Java

Ler array[0], array[1], array[2] manualmente deixa de ser prático por volta do elemento 3. Depois que você criou um array, o Java oferece várias formas de visitar cada elemento — escolha a que melhor se adapta ao que você precisa fazer. Esta página cobre o for baseado em índice, o for aprimorado (for-each), streams de array e como escolher entre eles.

O laço for clássico

O for baseado em índice é a forma mais flexível e é o único que fornece a posição atual:

int[] scores = {90, 85, 73, 100, 62};
for (int i = 0; i < scores.length; i++) {
  System.out.println(i + ": " + scores[i]);
}

Use-o quando precisar:

• do índice (para imprimi-lo, comparar vizinhos ou pular elementos)
• percorrer o array ao contrário — for (int i = scores.length - 1; i >= 0; i--)
• avançar mais de um passo — i += 2
• modificar o array — atribuindo a scores[i]

O limite é sempre i < array.length, nunca um número fixo. Se o array mudar de tamanho depois (ou for passado de outro lugar), o laço ainda funciona.

length é um campo, portanto não há parênteses: escreva scores.length, não scores.length(). (Strings são diferentes — String tem um método length().) Quando o array está vazio, length é 0 e o corpo do laço nunca é executado, que é exatamente o que você quer — sem verificações especiais necessárias. Veja o capítulo sobre o laço for para a mecânica geral.

O for aprimorado — "for-each"

Quando você só precisa do valor de cada elemento em ordem, o for aprimorado é mais curto e claro:

int[] scores = {90, 85, 73, 100, 62};
int sum = 0;
for (int score : scores) {
  sum += score;
}
System.out.println("sum = " + sum);

Leia o dois-pontos como "em": "para cada int score em scores." A variável de laço é uma cópia fresca de cada elemento. Você não tem acesso ao índice dessa forma, e não pode modificar o array por meio de score — atribuir a score apenas redefine a variável local.

Use o for aprimorado para "fazer algo com cada valor." Use o for clássico sempre que o índice importar.

Leitura vs. escrita dentro de um laço

Dentro de um for clássico, array[i] = novoValor modifica o array diretamente:

int[] scores = {90, 85, 73, 100, 62};
for (int i = 0; i < scores.length; i++) {
  scores[i] = scores[i] + 5;     // give everyone a 5-point bonus
}

O for aprimorado não consegue fazer isso para tipos primitivos — score = score + 5 altera apenas a cópia local:

for (int score : scores) {
  score = score + 5;             // no effect on scores
}

Para arrays de objetos, a variável de laço ainda referencia o mesmo objeto que o slot do array, portanto chamar métodos que modificam o objeto altera o que o array enxerga. Mas reatribuir a variável não tem efeito.

Streams sobre arrays

Para arrays numéricos, o helper Arrays.stream(...) oferece uma API no estilo pipeline:

import java.util.Arrays;

int[] scores = {90, 85, 73, 100, 62};
int total = Arrays.stream(scores).sum();
double avg  = Arrays.stream(scores).average().orElse(0);
int max     = Arrays.stream(scores).max().orElse(0);

Para arrays de objetos, Arrays.stream(...) retorna um Stream<T> com os métodos usuais filter/map/reduce:

String[] names = {"Ada", "Linus", "Grace"};
long shortOnes = Arrays.stream(names).filter(n -> n.length() <= 3).count();

Streams são expressivos, mas têm um custo — para laços internos muito frequentes, um for simples é mais rápido e fácil de depurar. Recorra a streams quando a intenção (soma, filtrar-e-contar, agrupar, transformar) é o que você quer tornar explícito. Veja Java streams para a API completa de pipeline.

forEach pelo lado do array

Não existe array.forEach(...). Os equivalentes mais próximos são Arrays.stream(arr).forEach(...) (numérico ou objeto) ou, para arrays de objetos, o atalho Arrays.asList(arr).forEach(...). Na maioria das vezes o for simples ou o for aprimorado é suficiente — não recorra ao forEach apenas para usar uma sintaxe diferente.

Escolhendo um laço

Um exemplo prático

O que vem a seguir

Agora você sabe criar arrays e percorrê-los em todas as direções. Dados do mundo real frequentemente são bidimensionais — uma grade, uma tabela, um tabuleiro — e o Java suporta isso com arrays multidimensionais, que são essencialmente arrays de arrays.

Prática