Artigos .NET C#: Trabalhando com arrays

Arrays são coleções de dados extremamente importantes em qualquer linguagem de programação. Sua grande vantagem está no fato de serem estruturas indexadas, ou seja, os itens dos arrays podem ser acessados através de índices, o que garante grande velocidade para essas operações.

Neste documento veremos como declarar e utilizar arrays na linguagem C#.

Declaração de arrays

A declaração de arrays é algo relativamente simples no C#. No entanto, é importante destacar que é essencial sabermos exatamente o tamanho que o array terá, o que acaba sendo uma limitação em alguns casos.

A declaração padrão para um array qualquer obedece a seguinte estrutura: 


tipo[] nomeDoArray = new tipo[tamanho_do_array];

Por exemplo, para um array do tipo inteiro (int), com 10 posições, a declaração seria da seguinte forma:

int[] array = new int[10];

Inserção de dados no array

Existem duas formas básicas para inserirmos dados nos arrays em C#. A primeira é realizarmos isso durante a declaração do mesmo. Dessa forma, poderíamos ter a declaração das seguintes formas:


int[] array1 = new int[5] { 1, 3, 7, 12, 8 };
int[] array2 = { 1, 3, 2, 7, 6 };

No primeiro caso temos uma declaração explícita de um array que conterá cinco números inteiros. Aqui, se passarmos menos ou mais de cinco números entre as chaves haverá um erro de compilação, uma vez que sabemos que o array tem cinco posições.

No segundo caso, a declaração da quantidade de elementos no array é implícita e depende de quantos itens temos entre as chaves. Nesse exemplo passamos cinco números; assim, array2 possui cinco posições e não há possibilidade de erro de compilação.

Outra forma de inserirmos os dados no array é acessando o item através de seu índice. Por exemplo, podemos fazer uma declaração simples e então iterarmos sobre todos os índices do array, adicionando os valores específicos para cada um deles, como a seguir:


  01 int[] array = new int[50];
  02 for (int i = 0; i < 50; i++)
  03 {
  04     array[i] = i + 1;
  05 }

Linha 01: declaração de um array inteiro com 50 posições;

Linha 02: definição de um loop for com 50 iterações, entre 0 e 49, com incremento unitário;

Linha 04: inserção de dados no array. Para cada iteração, o array, na posição i, receberá o valor de i + 1, ou seja, array[0] == 1, array[1] == 2, e assim por diante.

Acesso aos dados do array

O acesso aos dados do array é feito de forma extremamente simples, uma vez que estamos lidando com uma coleção indexada. Assim, basta acessarmos o índice específico e podemos obter o valor do elemento, como podemos ver abaixo:

Console.WriteLine(array[10]);

É importante notarmos, entretanto, que esse tipo de acesso pode gerar problemas. Se, no caso anterior, tivermos um array com menos que 11 posições (o índice 10 é o 11º elemento da coleção (0 a 10)), o código irá levantar uma exceção do tipo IndexOutOfRangeException. Portanto, é fundamental assegurar que estamos acessando um índice válido.

Iterações sobre os arrays

Uma das principais características das coleções, em qualquer linguagem de programação, são as iterações que podem ser realizadas sobre elas. No caso dos arrays em C# isso não é diferente. Assim, para iterarmos sobre os arrays existem basicamente duas opções: loops em que acessamos os índices no array diretamente (while ou for) ou o loop foreach, que faz isso internamente para nós. No código abaixo temos ambas as opções:


  01 for (int i = 0; i < 10; i++)
  02 {
  03     Console.WriteLine(array[i]);
  04 }
  05
  06 int i = 0;
  07 while (i < 10)
  08 {
  09     Console.WriteLine(array[i]);
  10     i++;
  11 }
  12
  13 foreach (int x in array)
  14 {
  15     Console.WriteLine(x);
  16 }

Linhas 01 a 04: acesso via índices do array utilizando um loop for, no qual o iterador é o inteiro “i”. Esse tipo de acesso era bem comum em linguagens como C e C++;

Linhas 06 a 11: acesso via índices do array utilizando um loop while, no qual o iterador é o inteiro “i”. Esse tipo de acesso é muito similar ao que vimos no loop for. Entretanto, existem algumas operações que precisam ser realizadas manualmente, como a declaração da variável inteira “i” (linha 06) e o incremento do mesmo (linha 10);

Linhas 13 a 16: acesso através do loop foreach, que itera sobre todos os elementos da coleção. Esse tipo de utilização só é possível porque no C# todas as coleções implementam a interface IEnumerable, ou sua forma genérica IEnumerable<T>, que oferecem a base do suporte às iterações via foreach.

Exemplo prático

A seguir temos um exemplo prático (mostrado em execução na Figura 1) de como utilizar os arrays em nossas aplicações C#:


  01 string[] pilotos = new string[4] { "Ayrton Senna", "Michael Schumacher", 
       "Lewis Hamilton", "Alain Prost" };
  02 Console.WriteLine(pilotos[3]);
  03 Console.WriteLine();
  04 pilotos[3] = "Rubens Barrichello";
  05 foreach (string piloto in pilotos)
  06 {
  07     Console.WriteLine(piloto);
  08 }

RUN

Linha 01: declaração do array “pilotos”, contendo quatro strings pré-definidas;

Linha 02: acesso ao índice “3” do array, mostrando na tela o nome “Alain Prost”;

Linha 03: inserção de linha em branco;

Linha 04: substituição do elemento no índice “3” do array (“Alain Prost”), que agora recebe o nome de “Rubens Barrichello”;

Linhas 05 a 08: utilização do loop foreach para iterar sobre o array. Nesse caso, como o array implementa IEnumerable<string>, podemos garantir que os quarto pilotos serão mostrados na tela com o código da linha 06.

Execução do exemplo C# Arrays
Figura 1. Execução do exemplo C# Arrays