C# - Conceitos - Apresentando Arrays

 Já falei sobre arrays mas relacionados com a linguagem VB .NET. O conceito em si é o mesmo mas a sintaxe em C# é diferente por isso vou começar do início para apresentar os Arrays e como usá-los na linguagem C#.

Vou começar com a definição de array da wikipédia (http://pt.wikipedia.org/wiki/Array) resumida:

Um Array é um conjunto de elementos de um mesmo tipo de dados onde cada elemento do conjunto é acessado pela posição no array que é dada através de um índice (uma sequência de números inteiros).  Um array de uma dimensão é também conhecido como vetor,e , um array de mais de uma dimensão e conhecido como uma matriz.

 

 

Agora uma definição mais geral:

Um array é uma estrutura de dados que contém uma série de dados ordenados, chamados "elementos". Os elementos são referenciados por número ordinal (índice), primeiro elemento é 1, segundo 2, etc. Os elementos podem ser de qualquer tipo, string, caractere, numérico, data, etc.

Se você não fugiu da escola vai lembrar do conceito de Matriz em matemática. Lembra ??? É a mesma coisa...

Uma matriz real (ou complexa) é uma função que a cada par ordenado (i,j) no conjunto Smn associa um número real (ou complexo).
Uma forma comum e prática para representar uma matriz definida na forma acima é através de uma tabela contendo m×n números reais (ou complexos).

Fonte : http://twixar.com/6v9

Declarando Arrays em C#

Na linguagem C#  os arrays possuem o índice com base zero, ou seja, o primeiro elemento do array possui o índice zero (0).

Um array de uma dimensão é declarado informando o tipo de dados do array seguido do nome do array, lembrando que devemos colocar colchetes ([]) depois do tipo do array e não após o seu nome:

Ex:  int[] tabela; ==> correto     int tabela[];  ==> incorreto

Na linguagem C# o tamanho do arrray não é parte do seu tipo, isso permite declarar uma array e em seguida atribuir qualquer array de objetos int a ele, sem considerar o seu tamanho:

Ex:    int[] numeros;                          //declara numeros como um array de inteiros de qualquer tamanho
         numeros = new int[10];          // numeros agora é um array de 10 elementos
         numeros = new int[20];          // numeros agora é um array de 20 elementos

Além de arrays de uma dimensão a linguagem C# suporta os seguintes tipos de arrays:

- Arrays com mais de uma dimensão :

    string[,] names;      
     int[,] array = new int[2, 2];

-  Array-of-arrays (jagged):

     byte[][] resultados;
     int[][] numArray = new int[][] { new int[] {1,3,5}, new int[] {2,4,6,8,10} };

Criando e inicializando um Array

Em C# declaramos um array assim :

string[] nomes;    //array nomes de qualquer tamanho

mas isso não cria o array para fazer isso devemos declarar:

nomes = new string[5];        //array de strings de 5 elementos 

finalmente para incializar o array fazemos assim:

nomes[0] = "José";
nomes[1] = "Carlos";
nomes[2] = "Macoratti";
nomes[3] = "Miriam";
nomes[4] = "Estela";

Observe o índice indicando a posição do elemento no array. O primeiro elemento é o zero e o último é 4. Assim temos 5 elementos no array com posições : 0,1,2,3 e 4.

Para um array de mais de uma dimensão a sintaxe usada pode ser:

string[,] names = new string[5,4];   //declara um array bidimensional com 5 linhas e 4 colunas

Existem outras formas de iniciar um array:

1- Uma Dimensão


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

string[] nomes = new string[3] {"Mac", "Jessica", "MiMi"};
 		  definindo o tamanho e o operador new

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

string[] nomes = new string[] {Mac", "Jessica", "MiMi"};
 		  omitindo o tamanho do array

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

string[] nomes = {"Mac", "Jessica", "MiMi"};
 		  Omitindo o operador new

2- Mais de uma Dimensão


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

string[,] amigos = new string[2, 2] { {"Mac","Jan"}, {"Mimi","Jeff"} };
 		  definindo o tamanho e o operador new

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

string[,] amigos = new string[, ] { {"Mac","Jan"}, {"Mimi","Jeff"} };
 		  omitindo o tamanho do array

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

string[,] amigos = { {"Mac","Jan"}, {"Mimi","Jeff"} };
 		  Omitindo o operador new

3- Arrays de Arrays (jagged arrays)


int[][] numeros = new int[2][] { new int[] {2,3,4}, new int[] {5,6,7,8,9} };
 
 definindo o tamanho e o operador new

 

int[][] numeros = new int[][] { new int[] {2,3,4}, new int[] {5,6,7,8,9} };
                                                    ou
int[][] numeros = { new int[] {2,3,4}, new int[] {5,6,7,8,9} };
 		  omitindo o tamanho do array

 

Acessando e percorrendo Arrays

Como você já sabe os elementos contidos nos arrays são identificados por um índice e é por este número que acessamos um determinado elemento no array.

Eu vou usar o Visual C# 2008 Express Edition nos exemplos deste artigo.

No exemplo a seguir eu estou declarando um array unidimensional chamado numeros do tipo int e criando e inicializando o array com 5 elementos :

private void Form1_Load(object sender, EventArgs e)

{

   int[] numeros = { 10, 9, 8, 7, 6 };

   listBox1.Items.Add("Primeiro elemento: " + numeros[0]);

   listBox1.Items.Add("Segundo elemento: " + numeros[1]);

   listBox1.Items.Add("Terceiro elemento: " + numeros[2]);

   listBox1.Items.Add("Quarto elemento: " + numeros[3]);
   listBox1.Items.Add("Quinto elemento: " + numeros[4]);

}

Note que para acessar um elemento eu utilizei o seu índice, e como em C# os arrays são base zero, o primeiro elemento tem o índice igual a zero (0).

Então para acessar um elemento em um array unidimensional eu uso a sintaxe:  nome_do_array[numero_do_indice]

Para um array de mais de uma dimensão somente temos que definir os demais índices do array. No exemplo a seguir eu declaro um array bidimensional chamado numeros2 e a seguir crio e inicio o array com 5 elementos:

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

         listBox2.Items.Add("numeros2[0,0] = " + numeros2[0, 0]);
         listBox2.Items.Add("numeros2[0,1] = " + numeros2[0, 1]);	
          listBox2.Items.Add("numeros2[1,0] = " + numeros2[1, 0]);
          listBox2.Items.Add("numeros2[1,1] = " + numeros2[1, 1]);
          listBox2.Items.Add("numeros2[2,0] = " + numeros2[2, 0]);
          listBox2.Items.Add("numeros2[2,1] = " + numeros2[2, 1]);
          listBox2.Items.Add("numeros2[3,0] = " + numeros2[3, 0]);
          listBox2.Items.Add("numeros2[3,1] = " + numeros2[3, 1]);
          listBox2.Items.Add("numeros2[4,0] = " + numeros2[4, 0]);
          listBox2.Items.Add("numeros2[4,1] = " + numeros2[4, 1]);

Observe que para acessar os elementos do array eu tive que usar os dois índices que indicam a posição do elemento no array.

Para você visualizar e entender melhor o conceito veja abaixo uma ilustração do array definido acima e a sua matriz correspondente:

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

   numeros2[0, 0] = 1
   numeros2[0, 1] = 2
   numeros2[1, 0] = 3
   numeros2[1, 1] = 4
   numeros2[2, 0] = 5
   numeros2[2, 1] = 6
   numeros2[3, 0] = 7
   numeros2[3, 1] = 8
   numeros2[4, 0] = 9
   numeros2[4, 1] = 10		 Matriz  2 x 5

Para atribuir valores a uma posição do array eu também uso os índices. Assim temos:

 int[,] matriz3x3 = { { 1, 0,0 }, { 0,1,0 }, { 0,0,1 } };  

Outro exemplo de array bidimensional:

string[,] livros  = {
                            {"Macbeth", "Shakespear", "ID12341"},
                            {"1984", "George Owell", "ID234234"},
                            {"ASP - Internet ", "Macoratti", "ID3422134"}
                        };
 		  Este array contém 3 linhas e 3 colunas. Para cada livro temos uma  linha e cada livro contém 3 colunas : titulo, autor e ID do livro.

numeros[4] = 100         //atribuindo o valor ao quarto elemento do array

numeros [1,1] = 200    //atribuindo o valor 200 ao elemento de posição [1,1] do array

Percorrendo Arrays

Deu para perceber que acessar e percorrer arrays com muitos elementos pode dar um trabalho danado. É para isso que servem os laços (loops), para percorrer arrays sem fazer esforço. Vejamos alguns dos principais laços usados:

O laço for é usado para ser executado um determinado número de vezes usando uma variável com um valor determinado e incrementando esta variável até o valor determinado. No exemplo abaixo a variável i recebe o valor inicial zero e a incrementa (I++) até que o seu valor seja menor que 10.

for (int i = 0; i < 10; i++)
{
    // codigo a ser executado
}

Assim podemos usar um laço for para percorrer um array existente ou atribuir valores a um array que foi declarado.

a) Exemplo:  Percorrer o array  numeros declarado a seguir e exibir os seus valores em um controle ListBox:

    int[] numeros = { 10, 9, 8, 7, 6, 5 };

    listBox1.Items.Clear();

   for (int i = 0; i < 6 ; i++)
   {
      listBox1.Items.Add("Elemento [" + i +"] = " + numeros[i]);
   }
  • O laço for usado inicia a partir do índice zero;
  • Percorre o array até que o valor de i seja menor que 6 , pois o array possui seis elementos mas começamos contar a partir de zero:  (0,1,2,3,4,5)
  • numeros[i] representa o array e i o índice atribuído a cada elemento

O resultado exibido no formulário Windows Forms será:

b) Exemplo:  Atribuir valores o array  inteiros declarado a seguir e exibir os valores em um controle ListBox.

int[] inteiros = new int[10];

int[] inteiros = new int[10];

listBox1.Items.Clear();
listBox1.Items.Add("Array inteiros => int[] inteiros = new int[10]");

for (int i = 0; i < 10; i++)
{
   inteiros[i] = i;
   listBox1.Items.Add("Elemento [" + i + "] = " + i );
}

 A atribuição esta sendo feita na declaração:  inteiros[i] = i;
O resultado obtido é visto na figura abaixo:

Podemos usar laços while e do-while para fazer a mesma operação lembrando que esses laços são executados enquanto certa condição esta sendo atendida.

Exemplo: Estrutura do laço while e do-while;

  while (i < 10)
  {
  }
-----------------------------------------------------------
  do
  {
  } while (i < 10);

A principal diferença entre o laço while e do-while é que no laço while , a expressão é verificada antes do início da execução do laço e se o resultado for falso o laço nunca será executado. No laço do-while a verificação é feita após a primeira execução.

O laço Foreach

O laço foreach pode ser usado para acessar cada elemento do vetor ou coleção.  A sintaxe usada é : 

foreach (<tipo> <variavel> in <coleção>)

Exemplo com vetor unidimensional:

     int[] numeros = new int[5];

        numeros [0] = 10;
        numeros [1] = 4;
        numeros [2] = 32;
        numeros [3] = 1;
        numeros [4] = 20;

        foreach (int i in numeros )
        {
             listBox1.Items.Add("i = " + i);
        }

Exemplo com vetor bidimensional:

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

 foreach (int i in numeros2 )
 {
        listBox1.Items.Add("i = " + i);
 }

Exemplo com laço foreach usando strings:

  string[] semana = new string[7];
 

  semana[0] = "Domingo";

  semana[1] = "Segunda-feira";

  semana[2] = "Ter‡a-feira";

  semana[3] = "Quarta-feira";

  semana[4] = "Quinta-feira";

  semana[5] = "Sexta-feira";

  semana[6] = "Sabado";


 foreach (string dia in semana)

 {

       listBox1.items.Add(dia);

 }

Usando os métodos e propriedades do objeto Array

Em C# arrays são objetos. A classe System.Array é a classe abstrata que é a base para todos os tipos de arrays.

Observação importanteObservação importante:
No .NET Framework versão 2.0, o Classe de Array implementa o System.Collections.Generic.IList<T>, System.Collections.Generic.ICollection<T>e System.Collections.Generic.IEnumerable<T> genérico interfaces.As implementações são fornecidos para matrizes em tempo de execução, e portanto não são visíveis para as ferramentas de documentação.Como resultado, as interfaces Genéricas não aparecem na sintaxe de declaração para a classe Array, e não há nenhum tópico de referência para membros de interface que são acessíveis somente por converter uma matriz para o tipo de interface Genérica (implementações de interface explícita).

A classe Array fornece propriedades e métodos para criar, manipular, procurar e ordenar arrays. Abaixo temos os mais importantes:

1- Propriedades

IsFixedSize

Retorna um valor indicando se um array possui um tamanho fixo ou não.

IsReadOnly

Retorna um a valor indicando se um array é somente-leitura ou não.

IsSynchronized

Retorna um a valor que indica se o acesso a um array é thread-safe ou não.

Length

Retorna o número total de itens em todas as dimensões de um array

Rank

Retorna o número de dimensões de um array

SyncRoot

Retorna um objeto que pode ser usado para sincronizar o acesso a um array.

2- Métodos

BinarySearch

 Procura em um array unidimensional ordenado por um valor usando o algoritmo de busca binário.

Clear

 Remove todos os itens de um array e define um intervalo de itens no array com valor zero.

Clone

 Cria uma cópia do Array.

Copy

 Copia uma seção de um array para outro array e realiza a conversão de tipos e boxing requeridas.

CopyTo

 Copia todos os elementos do array unidimensional atual para o array unidimensional especificado iniciando no índice de destino especificado do array.

CreateInstance

 Inicializa uma nova instância da classe Array.

GetEnumerator

 Retorna um IEnumerator para o Array.

GetLength

 Retorna o número de itens de um Array.

GetLowerBound

 Retorna o primeiro item de um Array.

GetUpperBound

 Retorna o último item de um Array.

GetValue

 Retorna o valor do item especificado no  Array.

IndexOf

 Retorna o índice da primeira ocorrência de um valor em um array de uma dimensão ou em uma porção do Array.

LastIndexOf

 Retorna o índice da última ocorrência de um valor em um array unidimensional ou em uma  porção do Array.

Reverse

 Reverte a ordem de um item em um array de uma dimensão ou parte do array.

SetValue

 Define o item especificado em um array atual para o valor definido.

Sort

 Ordena os itens de um array.

A seguir temos alguns exemplos de utilização das propriedades e métodos:

Array usado nos exemplos:

string[] Cores = { "vermelho", "verde", "amarelo", "laranja", "azul" };

Obter o tamanho do Array
  Cores.Length);
 
Ordenar o Array
  Array.Sort(Cores)
 
Inverter a ordem dos itens no Array
  Array.Reverse(Cores)
 
Usar GetLowerBound/GetUpperBound  for( int j = Cores.GetLowerBound(0); j <= Cores.GetUpperBound(0); j++)
 {
        listBox2.Items.Add("Cores[0] = " + j + " " + Cores[j]);
 }
 

Verificando se o Array tem tamanho fixo

 if (Cores.IsFixedSize)

 {

   listBox2.Items.Add("O array e fixo");

   listBox2.Items.Add(" tamanho => (Cores.Lenght) = " + Cores.Length);

   listBox2.Items.Add(" intervalo => (Cores.Rank) = " + Cores.Rank);

 }
Realizando uma busca binária no Array

 

 object oCor = "verde";
 

 int retorno = Array.BinarySearch(Cores, oCor);

 if(retorno >=0)

     listBox2.Items.Add("Indice do Item " + retorno.ToString());

 else

     listBox2.Items.Add("Item nÆo localizado");
Obtendo o índice de um item do Array
 int ind = Array.IndexOf(Cores, "verde");
 listBox2.Items.Add("O índice do item 'verde' e " + ind);
 

E com isso creio que dei uma visão geral sobre os Arrays na linguagem C#. Consulte a documentação para mais exemplos e mais detalhes.

Pegue o projeto com os exemplos do artigo aqui: C_Arrays.zip

Eu sei é apenas C# mas  eu gosto.

    Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter

Veja os Destaques e novidades do SUPER DVD Visual Basic  (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Veja mais sistemas completos para a plataforma .NET no Super DVD .NET , confira...

Quer aprender C# ??

Chegou o Super DVD C#  com exclusivo material de suporte e vídeo aulas com curso básico sobre C#.

Veja também os Cursos com vídeo aulas e projetos exemplos:

Referências:

José Carlos Macoratti