Operações básicas com arrays unidimensionais

1. Introdução

O que normalmente a gente quer fazer com arrays?

Bora listar as operações básicas:

• Ler e alterar elementos do array pelo índice.
• Buscar um elemento pelo valor.
• Copiar o array, criar “fatias” (parte do array).
• Ordenar o array.
• Reverter (inverter) o array.
• Preencher o array com um valor.
• Verificar se existe um elemento (se o array contém um valor).
• Mudar o tamanho (resize).

No mundo real, você vai esbarrar nessas ações o tempo todo — tipo “tem algum valor acima de 4000?”, “acha o primeiro preço menor que 1000”, “ordena os preços em ordem crescente” e por aí vai.

E pra tudo isso a gente tem funções

arr[n] = x

Array.IndexOf(arr, v)

Array.Exists(arr, pred)

Array.Sort(arr)

Array.Reverse(arr)

arr.Clone(), Array.Copy

Array.Fill(arr, val)

Array.Resize(ref arr, len)

arr.Max(), arr.Min()

2. Ler e alterar elementos pelo índice

Isso aqui você já viu, mas bora reforçar com um exemplo simples (imagina que temos um array de notas):

// Array de notas do estudante
int[] grades = { 4, 3, 5, 2, 5 };

// Ler a primeira nota
int firstGrade = grades[0];
Console.WriteLine($"Primeira nota: {firstGrade}");

// Alterar a última nota pra "excelente" (5)
grades[^1] = 5;
Console.WriteLine("Última nota alterada: " + grades[^1]);

O importante aqui: indexação começa do zero, tentar acessar um índice que não existe dá erro IndexOutOfRangeException — clássico de entrevista e da vida real.

3. Buscar elemento no array

A gente tem duas funções que procuram um elemento no array e devolvem o índice se achar.

Função Array.IndexOf(value [, from])

A função Array.IndexOf procura o elemento começando do início do array. Se achar, devolve o índice. Se não — devolve -1.

Mas e se você quiser achar as próximas ocorrências desse elemento? Pra isso, passa o segundo parâmetro pra Array.IndexOf — o índice de onde ela começa a procurar. Tem que ser o índice do último achado + 1.

Bora achar todas as ocorrências do número 2 no nosso array:

int[] grades = { 4, 3, 5, 2, 5, 2 };
int x = 2; // elemento que estamos procurando

int index = Array.IndexOf(grades, x);
while (index != -1)
{
    Console.WriteLine($"Elemento {x} achado na posição: {index}");
    // Procura o próximo índice, começando de index + 1
    index = Array.IndexOf(grades, x, index + 1);
} 

Função Array.LastIndexOf(value [, from])

A função Array.LastIndexOf procura o elemento começando do final do array. Se achar, devolve o índice. Se não — devolve -1. O resto é igual à Array.IndexOf.

Bora achar todas as ocorrências do número 2 no nosso array, mas procurando do final:

int[] grades = { 4, 3, 5, 2, 5, 2 };
int x = 2; // elemento que estamos procurando

int index = Array.LastIndexOf(grades, x);
while (index != -1)
{
    Console.WriteLine($"Elemento {x} achado na posição: {index}");
    // Procura o próximo índice, começando da posição anterior - 1
    index = Array.LastIndexOf(grades, x, index - 1);
}

4. Verificar se o elemento existe no array

Pra checar se um elemento existe, tem a função Contains. Esse método retorna true se o array tiver o elemento. Pra funcionar, tem que importar o módulo System.Linq. Exemplo:

using System.Linq; // Importa using System.Linq; se não tiver

bool hasExcellent = grades.Contains(5); 
Console.WriteLine($"Tem nota cinco? {hasExcellent}");

Bem simples e direto.

5. Reverter array: Array.Reverse

Se quiser inverter o array “de trás pra frente”, usa:

int[] grades = { 2, 3, 4, 5 };

// Inverte o array
Array.Reverse(grades);
Console.WriteLine("Notas invertidas: " + string.Join(", ", grades));

Bem útil pra pegar os dados “mais recentes” ou só pra ver o mundo de cabeça pra baixo mesmo.

6. Ordenar array: Array.Sort

Mais cedo ou mais tarde você vai querer ordenar um array. O jeito mais fácil e seguro é usar a função padrão de ordenação:

int[] grades = { 4, 3, 5, 2, 5 };
// Ordena em ordem crescente
Array.Sort(grades);
Console.WriteLine("Notas ordenadas: " + string.Join(", ", grades));

Essa função também ordena strings, mas em ordem alfabética.

Ordenar em ordem decrescente

O Array.Sort padrão só ordena em ordem crescente. Pra ordenar em ordem decrescente, faz a ordenação e depois inverte:

Array.Sort(grades); // Primeiro crescente
Array.Reverse(grades); // Depois inverte
Console.WriteLine("Em ordem decrescente: " + string.Join(", ", grades));

Atenção: muita gente esquece que a ordenação é “no lugar”: o array muda, não retorna um novo. Se quiser manter a ordem original, copia o array antes.

7. Clonar array: Clone e Array.Copy

Se precisar criar uma cópia (e não estragar o array original enquanto mexe), usa os métodos Clone() e Array.Copy().

O método Clone() é chamado no array e retorna uma cópia completa.

O método Array.Copy() precisa que você passe os dados:

• array de origem;
• array pra onde vai copiar;
• quantas posições copiar.

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

// Jeito 1: Clone()
// Funciona pra arrays uni e multidimensionais, mas retorna object, tem que fazer type cast:
int[] copy1 = (int[]) original.Clone();

// Jeito 2: Array.Copy
int[] copy2 = new int[original.Length];
Array.Copy(original, copy2, original.Length);

Detalhe importante: arrays são copiados por valor se forem tipos primitivos (int, double). Se for array de objetos, só copia as referências! (chamado de “cópia superficial”).

8. Preencher array com valor: Array.Fill

Quer “zerar” o array ou preencher tudo com cinco? Tem um método massa pra isso — Array.Fill:

int[] grades = new int[5];
Array.Fill(grades, 5); // Agora todos os elementos são 5
Console.WriteLine("Estudante hipoteticamente perfeito: " + string.Join(", ", grades));

Útil quando precisa inicializar rápido o array com um valor específico.

9. Buscar valor máximo e mínimo

O módulo System.Linq trouxe vários métodos úteis pros arrays, e dois deles devolvem o valor mínimo e máximo do array. São eles Max() e Min().

Bora achar a maior e a menor nota do array:

int maxGrade = grades.Max();
int minGrade = grades.Min();
Console.WriteLine($"Nota máxima: {maxGrade}, mínima: {minGrade}");

Não esquece de adicionar using System.Linq; pra usar esses métodos.