EnglishEnglish العربيةالعربية PortuguêsPortuguês Japanese日本語

Arrays

Arrays são contêineres para armazenar dados do mesmo tipo. Esta lição cobre como usar arrays em Java.

O que é um Array

Um array é uma coleção de tamanho fixo de elementos do mesmo tipo.

Características do Array

Característica Descrição
Tamanho fixo O tamanho não pode ser alterado após a criação
Mesmo tipo Todos os elementos devem ser do mesmo tipo
Armazenamento contíguo Os elementos são armazenados sequencialmente na memória
Acesso por índice Acesse elementos por índice (começando de 0)

Declaração e Inicialização

Método 1: Declarar Primeiro, Inicializar Depois

JAVA 
// Declarar array
int[] arr;

// Inicializar (alocar espaço)
arr = new int[5];  // 5 elementos, valor padrão é 0

Método 2: Declarar e Inicializar

JAVA 
// Especificar tamanho
int[] arr = new int[5];

// Atribuição direta
int[] arr = {1, 2, 3, 4, 5};

Exemplo: Inicialização de Array

JAVA 
public class ArrayInit {
    public static void main(String[] args) {
        // Método 1: Especificar tamanho
        int[] arr1 = new int[3];
        arr1[0] = 10;
        arr1[1] = 20;
        arr1[2] = 30;
        
        // Método 2: Atribuição direta
        int[] arr2 = {10, 20, 30};
        
        // Método 3: new + atribuição
        int[] arr3 = new int[]{10, 20, 30};
        
        System.out.println(arr2[0]);  // 10
        System.out.println(arr2[1]);  // 20
        System.out.println(arr2[2]);  // 30
    }
}
▶ Experimente
⚠️ Nota: Os índices do array começam em 0. O índice máximo é comprimento - 1. Acessar fora dos limites lança ArrayIndexOutOfBoundsException.

Acesso e Modificação

JAVA 
int[] arr = {10, 20, 30, 40, 50};

// Acessar elementos
int first = arr[0];   // 10
int third = arr[2];   // 30

// Modificar elementos
arr[1] = 200;         // Mudar 20 para 200

// Obter comprimento do array
int len = arr.length; // 5

Travessia de Arrays

Método 1: Loop for Regular

JAVA 
int[] arr = {10, 20, 30, 40, 50};

for (int i = 0; i < arr.length; i++) {
    System.out.println("arr[" + i + "] = " + arr[i]);
}

Método 2: Loop for-each

JAVA 
int[] arr = {10, 20, 30, 40, 50};

for (int num : arr) {
    System.out.println(num);
}

Exemplo: Calcular Média

JAVA 
public class ArrayAverage {
    public static void main(String[] args) {
        int[] scores = {85, 92, 78, 96, 88};
        int sum = 0;
        
        for (int score : scores) {
            sum += score;
        }
        
        double avg = (double) sum / scores.length;
        System.out.println("Média: " + avg);  // 87.8
    }
}
▶ Experimente

Classe Utilitária Arrays

java.util.Arrays fornece métodos utilitários para operações com arrays.

Métodos Comuns

Método Descrição Exemplo
sort() Ordenar Arrays.sort(arr)
copyOf() Copiar Arrays.copyOf(arr, newLen)
fill() Preencher Arrays.fill(arr, value)
equals() Comparar Arrays.equals(arr1, arr2)
toString() Converter para string Arrays.toString(arr)
binarySearch() Busca binária Arrays.binarySearch(arr, key)

Exemplo: Usando Arrays

JAVA 
import java.util.Arrays;

public class ArraysDemo {
    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 1, 9, 3};
        
        // Ordenar
        Arrays.sort(arr);
        System.out.println("Ordenado: " + Arrays.toString(arr));
        // [1, 2, 3, 5, 8, 9]
        
        // Copiar
        int[] arr2 = Arrays.copyOf(arr, 3);
        System.out.println("Primeiros 3: " + Arrays.toString(arr2));
        // [1, 2, 3]
        
        // Preencher
        int[] arr3 = new int[5];
        Arrays.fill(arr3, 100);
        System.out.println("Preenchido: " + Arrays.toString(arr3));
        // [100, 100, 100, 100, 100]
        
        // Buscar (deve ser ordenado primeiro)
        int index = Arrays.binarySearch(arr, 5);
        System.out.println("Índice de 5: " + index);  // 3
    }
}
▶ Experimente

Arrays Bidimensionais

Um array bidimensional pode ser pensado como "um array de arrays".

Declaração e Inicialização

JAVA 
// Método 1: Especificar tamanho
int[][] matrix = new int[3][4];  // 3 linhas, 4 colunas

// Método 2: Atribuição direta
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

Exemplo: Travessia de Array 2D

JAVA 
public class TwoDArrayDemo {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        // Travessia
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
        // Saída:
        // 1 2 3
        // 4 5 6
        // 7 8 9
    }
}
▶ Experimente

Exemplo: Transposição de Matriz

JAVA 
public class MatrixTranspose {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6}
        };
        
        // Transpor: 2 linhas 3 colunas → 3 linhas 2 colunas
        int[][] transposed = new int[3][2];
        
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                transposed[j][i] = matrix[i][j];
            }
        }
        
        // Imprimir matriz transposta
        for (int[] row : transposed) {
            System.out.println(java.util.Arrays.toString(row));
        }
        // [1, 4]
        // [2, 5]
        // [3, 6]
    }
}
▶ Experimente

Varargs (Argumentos Variáveis)

Varargs permitem que métodos aceitem um número variável de argumentos.

Sintaxe

JAVA 
public static int sum(int... numbers) {
    int total = 0;
    for (int num : numbers) {
        total += num;
    }
    return total;
}

Exemplo: Varargs

JAVA 
public class VarargsDemo {
    public static void main(String[] args) {
        System.out.println(sum(1, 2));           // 3
        System.out.println(sum(1, 2, 3));        // 6
        System.out.println(sum(1, 2, 3, 4, 5));  // 15
    }
    
    public static int sum(int... numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }
}
▶ Experimente
⚠️ Nota: Varargs deve ser o último parâmetro em um método, e um método só pode ter um parâmetro varargs.

Algoritmos Comuns de Array

Exemplo: Bubble Sort

JAVA 
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 1, 9, 3};
        
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        
        System.out.println(java.util.Arrays.toString(arr));
        // [1, 2, 3, 5, 8, 9]
    }
}
▶ Experimente

Exemplo: Encontrar Máximo

JAVA 
public class FindMax {
    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 1, 9, 3};
        int max = arr[0];
        
        for (int num : arr) {
            if (num > max) {
                max = num;
            }
        }
        
        System.out.println("Máximo: " + max);  // 9
    }
}
▶ Experimente

❓ Perguntas Frequentes

P: O tamanho do array pode ser alterado? R: Não. O tamanho do array é fixo. Use ArrayList se precisar de dimensionamento dinâmico.

P: Os arrays têm valores padrão? R: Sim. int é 0, double é 0.0, boolean é false, e tipos de referência são null.

P: Qual algoritmo de ordenação o Arrays.sort() usa? R: Para primitivos, usa quicksort de pivô duplo. Para objetos, usa TimSort (uma variante do merge sort).

📖 Resumo

📝 Exercícios

  1. Operações com array: Crie um array com 10 elementos, atribua valores 1-10, depois imprima em ordem reversa
  2. Encontrar máximo/mínimo: Encontre os valores máximo e mínimo em um array
  3. Bubble sort: Implemente o algoritmo bubble sort para ordenar um array em ordem crescente

Próxima Lição

Na próxima lição, aprenderemos sobre Prática: Fundamentos — aplicando o conhecimento das primeiras 7 lições.

100%