Quando se está trabalhando com programação, é necessário gerir diversos dados o tempo todo durante a aplicação. Quanto maior for o sistema, mais dados são necessários gerenciar. Muitas vezes é necessário armazenar diversos dados com o mesmo objetivo, mas que fica difícil administrar diversas variáveis diferentes, uma para cada um.

Para resolver isso foi criado o array.

O Array é a forma mais comum de armazenar conjunto de dados relacionados entre si. Ele permite armazenar vários valores usando apenas uma variável, podendo acessá-los individualmente, como se fosse uma única variável, ou todos juntos em sequência, permitindo uma forma mais fácil de gerenciar.

Criando Arrays

O acesso e manipulação em arrays é muito eficiente, mas também possuem tamanho fixo, uma vez criado, não é possível aumentar ou diminuir o tamanho, sendo necessário criar um array maior ou menor e copiar os valores do anterior para o novo.

A maioria das linguagens não permite que seja criado um arrays que armazene tipos de valores diferentes, sendo necessário que todos os valores tenham o mesmo tipo.

Criação com passagem de valores

A criação de uma array é feita da seguinte forma:

tipo[] nomeDoArray = { valor1, valor2 };

Onde:

• "tipo" é o tipo das variáveis que vão ser armazenadas.
• "nomeDoArray" é o nome que será dado à variável.
• "valor1" e "valor2" serão os dados que serão armazenados.

Os valores devem ser passados dentro do colchete e todos devem ter o mesmo tipo que foi passado no array. Após passado os valores, o C# vai criar um array com o tamanho da quantidade de valores passados.

Por exemplo:

int[] numeros = { 1, 2, 3 };

Isso vai criar um array de inteiros com o nome "numeros", com tamanho de três posições e com três valores: "1", "2" e "3".

Apesar de algumas vezes ser conveniente passar os valores logo no momento da criação, outras vezes o valor somente será passado depois da criação, como durante a execução recebendo um valor do usuário. Ter que colocar valores sempre for criar um array acaba sendo um trabalho adicional desnecessário, por isso que as linguagens possuem uma forma de criar sem precisar passar valores.

Criação sem passagem de valores

Para que não seja necessário sempre escrever valores, mesmo quando não vai utilizá-los, é possível criar o array apenas passando o tamanho que ele vai ter.

A criação do array sem passar valores é feita da seguinte forma:

tipo[] nomeDoArray = new tipo[tamanho];

Por exemplo:

int[] numeros = new int[3]

Isso vai criar um array de três posições. Também será passado um valor padrão para eles, no caso de inteiros, todos vão iniciar com zero.

Também é possível criar arrays dentro de arrays, como por exemplo para criar um tabuleiro de xadrez, que necessita de dois arrays, uma para as linhas, outra para as colunas. Cada array vai ser representado sendo separados por vírgula.

// com valores
int[,] arrayBidimensional = { { 1, 2 }, {3, 4} }

// sem valores
int[,] arrayBidimensional = new int[2, 2]

Acessando os valores dos arrays

Para acessar um elemento de um array existente, somente é necessário colocar o nome do array, seguido de colchetes com o valor da posição desejada dentro. O valor poderá ser manipulado da mesma forma que seria com uma variável normal, permitindo ser imprimido e até ser alterado, com a diferença que ele vai estar dentro do array.

Por exemplo:

int[] numeros = {1, 2, 3};

Console.WriteLine(numeros[1]);

Mas isso tem um problema.

O valor mostrado não será o número "1", e sim o "2", que é o segundo elemento, e não o primeiro.

Por que isso ocorre?

Quando é criado um array, na memória, os valores do array são armazenados um do lado do outro. Isso permite que, por baixo dos panos, o array salve apenas o endereço do primeiro elemento, e os outros sejam acessados por meio de um cálculo matemático.

Na prática, isso fez com que as linguagens não nomeassem o primeiro elemento como "1", e sim como "0", fazendo com que todos os elementos sejam identificados como um valor a menos que sua real posição. Ou seja, para poder acessar o primeiro elemento, seria necessário colocar na posição o número "0", para acessar o segundo seria o "1" e assim por diante.

Por exemplo:

int[] numeros = {1, 2, 3};

Console.WriteLine(numeros[0]);

Agora sim o valor impresso no console será o "1", e não mais o "2".

Para acessar usando os valores um array multidimensional, vai ser necessário passar a posição em cada array. Imaginando como um array bidimensional, ou seja, com apenas dois arrays, um dentro do outro, seria como em um tabuleiro de xadrez, onde é necessário saber a linha e a coluna para achar uma casa em específico.

Por exemplo:

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

Console.WriteLine(numeros[1,0]);

A primeira posição vai ser para escolher o array, nesse caso, foi selecionado a posição "1", então será o segundo array, que possui os valores "{3, 4}", a segunda posição vai ser para escolher o valor dentro desse array, nesse caso, foi selecionado a posição "0", então vai ser o primeiro valor do array o "3". Passando esses valores, é impresso o número "3".

Para alterar algum valor do array, pode ser feito dessa mesma forma.

Por exemplo:

int[] numeros = {1, 2, 3}
numeros[2] = 15;

Isso altera o valor do "3" para "15". Agora o array é "{1, 2, 15}".

Acessando todos os valores

Algumas vezes pode ser necessário acessar todos os valores em ordem, mas colocar a posição de cada um, um por um, acaba sendo uma opção inviável, ainda mais quando se trabalha com arrays muito grandes. Uma forma simples de acessar seria utilizando laços de repetição.

Usando For

Para usar o "For", é necessário duas coisas: um contador e o tamanho do array.

O contador é necessário para ir "contando o número" de vezes que está se repetindo, para saber quando é a última repetição e parar de repetir. O contador é uma variável, que geralmente é chamada de "i".

O tamanho do array é necessário por causa que é necessário passar um tamanho, para não ter o risco de tentar acessar um elemento fora do array e dar um erro. Caso não tenha o tamanho do array, poderá usar o ".Length", que retorna o tamanho do conjunto de dados passado para ela.

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

for(int i=0; i < numeros.Length; i++)
{
Console.WriteLine(numeros[i]);
}

O "For" é dividido em três partes separadas por ponto e vírgula: A primeira, "int i=o", cria o contador, iniciando em zero. A segunda, "i < numeros.Length", verifica se o valor do contador é menor que o tamanho array antes de cada vez que for executar a instrução dentro dos colchetes. A terceira, "i++", aumenta o valor do contador em um a cada vez que uma repetição é terminada.

O "numeros[ i ]" aproveita o número do contador para passar cada posição do array a cada vez que for repetido, por isso é necessário que o contador seja iniciado em zero, senão seria necessário criar outra variável para isso, o que é desnecessário.

Usando Foreach

Uma forma mais concisa e simples é o "Foreach". Ele permite passar por todos os elementos até o fim sem precisar de um contador e sem precisar saber o tamanho.

Para ser usado, é criado uma variável que recebe o valor de cada posição do array e ela poderá ser usada para manipular o valor.

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

foreach (int numero in numeros)
{
Console.WriteLine(numero);
}

Dentro do "Foreach" é criado uma variável que possui o mesmo tipo do array, nesse caso a variável "numero" com tipo o "int", que receberá os valores do array, um por um, até o fim da repetição. Após o "in" será o array que será usado. A variável criada pode ser usada para imprimir o valor recebido de cada repetição no console.

Conclusão

Agora que você aprendeu a utilizar arrays, exercite o aprendizado utilizando-os em seus programas para manipular grande quantidade de dados, como receber notas de vários alunos e fazer uma média e exibir o resultado ou fazer um jogo da velha funcional usando arrays bidimensionais.

Caso queira se desafiar mais, você pode estudar estruturas de dados mais avançadas, como listas encadeadas, que é um array que possui tamanho dinâmico usando ponteiros.

Até a próxima.