Arrays em Java

Arrays são estruturas que armazenam coleções de valores do mesmo tipo. Enquanto uma variável comum armazena apenas um valor, um array pode armazenar diversos elementos, acessados por índice.

Declaração de arrays

Um array pode ser declarado de duas formas equivalentes:

int[] numbers;
// ou
int numbers[];

Após a declaração, o array pode ser inicializado com um tamanho fixo:

int[] numbers = new int[4]; // array com 4 elementos do tipo int

A construção new int[4] aloca espaço para 4 inteiros, que são automaticamente preenchidos com o valor padrão 0.

Também é possível declarar e inicializar o array na mesma linha:

int[] numbers = new int[4];
int[] outros = new int[5];

O valor inicial de cada elemento depende do tipo:

• Tipos numéricos (como int, float, char): 0
• boolean: false
• Tipos de referência (como String): null

Inicialização com valores definidos

É possível especificar os valores do array diretamente na criação:

int[] numbers = new int[] {1, 2, 3, 5};

// ou de forma mais concisa:
int[] outros = {1, 2, 3, 5};

Nesses casos, não é necessário informar o tamanho entre colchetes — ele será inferido com base na quantidade de elementos.

Acesso e modificação de elementos

Elementos de um array podem ser acessados ou alterados usando seu índice:

int[] numbers = new int[4];

numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 4;
numbers[3] = 100;

System.out.println(numbers[2]); // imprime 4

A indexação começa em zero. Assim, numbers[2] acessa o terceiro elemento.

Tentar acessar um índice fora dos limites, como numbers[5], gera um erro de tempo de execução (ArrayIndexOutOfBoundsException).

Propriedade length

Arrays possuem a propriedade length, que retorna a quantidade de elementos:

int[] numbers = {1, 2, 3, 4, 5};
int size = numbers.length; // 5

É comum acessar o último elemento assim:

int last = numbers[numbers.length - 1];

Arrays multidimensionais

Além dos arrays unidimensionais, Java também suporta arrays com múltiplas dimensões, como tabelas.

Array bidimensional

int[][] matrix = {
    {0, 1, 2},
    {3, 4, 5}
};

Ou criado com tamanho explícito:

int[][] matrix = new int[2][3]; // 2 linhas, 3 colunas

Visualmente, um array bidimensional pode ser visto como uma tabela com linhas e colunas:

Acesso a um elemento:

matrix[1][0] = 44;
System.out.println(matrix[1][0]); // imprime 44

Array tridimensional

int[][][] cubo = new int[2][3][4];

Arrays irregulares (jagged arrays)

Arrays multidimensionais em Java não precisam ter subarrays com o mesmo tamanho:

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

Esse tipo é conhecido como array irregular.

Laço for-each

Java possui uma forma simplificada para percorrer arrays, chamada for aprimorado (ou for-each):

int[] array = {1, 2, 3, 4, 5};
for (int value : array) {
    System.out.println(value);
}

Esse laço é útil para leitura, mas não permite alterar os elementos diretamente.

Comparação com for tradicional

Com for tradicional é possível alterar os elementos:

for (int i = 0; i < array.length; i++) {
    array[i] *= 2;
    System.out.println(array[i]);
}

Iterando arrays multidimensionais

Para percorrer arrays bidimensionais, utiliza-se laços aninhados:

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.printf("%d ", matrix[i][j]);
    }
    System.out.println();
}

O primeiro laço percorre as linhas, e o segundo, os elementos de cada linha. Esse padrão pode ser estendido para arrays com mais dimensões.

📝 Exercícios

Tarefa 1

Quantos elementos existem no seguinte array?

int[][][] nums = new int[3][2][3];

Alternativas:

• 0
• 2
• 3
• 8
• 18

3 × 2 × 3 = 18

Tarefa 2

O que será exibido no console ao executar o seguinte código?

int[][] nums = {
    {1, 2},
    {3, 4},
    {5, 6}
};

System.out.println(nums[3][2]);

Tarefa 3

Escreva um programa que calcule a soma de todos os elementos do array abaixo utilizando um laço:

int[] numbers = {5, 10, 15, 20};

int[] numbers = {5, 10, 15, 20};
int sum = 0;

for (int i = 0; i < numbers.length; i++) {
    sum += numbers[i];
}

System.out.println("Soma: " + sum); // Soma: 50

Tarefa 4

Considere o array abaixo. Escreva um programa que calcule e exiba a soma de todos os seus elementos:

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

int sum = 0;
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        sum += matrix[i][j];
    }
}

System.out.println("Soma: " + sum);

Soma: 45