Já vimos diversos tipos de Array a já aprendemos o que são Classes de Coleção, se você não viu ou não conhece procure nos Posts Relacionados no final da página.

Hoje vamos ver a Classe de Coleção Queue e Stack.

Queue

Essa classe utiliza o famoso conceito FIFO (First-in, First-out: primeiro a entrar, primeira a sair).

Imagine 3 potes vc enche o pote 1, o pote 2 e o pote 3, o pote 1 foi o primeiro a ser preenchido, agora você vai esvaziar o pote 1 depois o pote 2 e em seguida o pote 3. Pronto!

using System;
using System.Collections;

// instânciamos uma nova fila
 Queue novaFilaN = new Queue();

 // Criamos um array com valores
 int[] nums = new int[]{2, 4, 6, 7, 8, 9};

 // inserimos valores na fila
 foreach (int numeros in nums)
 {
     novaFilaN.Enqueue(numeros);
     Console.WriteLine(numeros + "<- Enfileramos\n");
 }

 Console.WriteLine("\n Nossa Fila está assim: ");

 // percorremos a fila
 foreach (int num in novaFilaN)
 {
     Console.WriteLine(num);
 }

 Console.WriteLine("\n --- Agora vamos retirar os valores da fila --- \n");
 // esvaziamos a fila

 while (novaFilaN.Count > 0)
 {
     int number = (int)novaFilaN.Dequeue();
         /** O casting é nesessário pois a Classe de Coleção Queue
          *  é uma classe Generalizada e armazena os valores como object
          *  OBS: Não confundam classes Generalizadas com classes Genéricas
          */
     Console.WriteLine(number + " <- Retiramos ");
 }

A saída vai ser essa:

Stack

A classe Stack implementa o mecanismo LIFO (Last-In, First-Out, último a entrar é o primeiro a sair).

É como uma pilha de pratos, o último prato colocado é o primeiro a ser retirado da pilha =D

Stack pilha = new Stack();

 int[] numeros = new int[] { 2, 4, 6, 7, 8, 9 };

 foreach (int num in numeros)
 {
pilha.Push(num);
Console.WriteLine(num + " <- empilhamos\n");
 }

 Console.WriteLine("\n Nossa Pilha está assim: ");

 // percorremos a pilha
 foreach (int numbs in pilha)
 {
Console.WriteLine(numbs);
 }

 Console.WriteLine("\n --- Agora vamos retirar os valores da fila --- \n");

 //esvaziamos a pilha
 while (pilha.Count > 0)
 {
int number = (int)pilha.Pop();
Console.WriteLine(number + " <- Retiramos da Pilha");
 }

A saída será essa:

Até a próxima!

No meu último post, falamos sobre Arrays, agora você aprenderá o que é uma Classe de Coleção e qual a diferença entre ela e um Array.

Classes de Coleção derivam do namespace System.Collection , visite Object Browser do Visual Studio 2008 – CTRL+ALT+J, que colecionam elementos só que de uma maneira muito especial.

As classes base de coleção armazenam e retornam seus elementos como umo bjetos (object), isso quer dizer que ao contrário de um Array convencional, que você pode criar ele do tipo int e os valores são armazenados diretamente como um inteiro. Uma classe de coleção os valores sofrerão boxing (explicarei em outro post) isso quer dizer que o valor não fica na pilha mas sim no heap, na pilha fica apenas um alias para o elemento no heap, deu pra entender?

OBS: Existe classes de coleção que nem sempre usam object como tipo de elemento e que podem sim armazenar tipo-valor assim como tipo-referência, mas esse não é o nosso caso agora…

ArrayList

ArrayList é muito bom para misturar elementos além de ter características que um Array comum não tem, exemplo:

• Para redimensionar um Array, você precisa criar um novo maior copiar os elementos para esse novo Array ou se for no caso de diminuir criar um Array menor e omitir elementos.
• Para adicionar um elemento ou remover você terá que redimensionar, em conclusões finais você terá que seguir a teoria do que foi dito acima.

Com um ArrayList essa limitação acaba, para remover, adicionar e inserir nós usaremos métodos.

Veremos aqui alguns desses métodos e propriedades da classe de coleção ArrayList.

using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;

namespace ArrayList0
{
    class Program
    {
        static void Main(string[] args)
        {
            // Primeiro criamos o nosso objeto ArrayList chamado de meuAL
            ArrayList meuAL = new ArrayList();

            // Mostramos a capacidade do nosso ArrayList, nesse caso
            // não precisamos de parênteses () porque é uma propriedade
            // e não um método
            Console.WriteLine("1- O ArrayList.Capacity é {0} \n", meuAL.Capacity);

            // Populamos o nosso ArrayList
            Console.WriteLine("2- Populando ArrayList...");
            int z = 0;
            for (int i = 5; z < i; i--)
            {
                // Repare que utilizamos um método
                // não atribuimos mais valor do elemento
                // ao indice como antes: meuAL[0] = valor
                meuAL.Add(i);
            }

            // Agora da pra perceber que a capacidade do ArrayList
            // aumentou dinâmicamente ao adicionar-mos elementos
            Console.WriteLine("\n3- O ArrayList.Capacity agora é: {0}\n", meuAL.Capacity);

            // A propriedade Count contém o número de elementos
            Console.WriteLine("4- ArrayList.Count é: {0} \n", meuAL.Count);

            // Imprimimos os valores dos elementos na tela
            for (int y = 0; y < meuAL.Count; y++)
            {
                try
                {
                    // Observe que é necessário fazer casting dos elementos
                    // isso porque os elementos armazenados no ArrayList
                    // são objetos, quando valores são inseridos com o método
                    // Add() ou Insert() eles sofrem boxing e são armazenados
                    // no heap e não na pilha
                    Console.WriteLine("O índice {0} = {1}", y, (int)meuAL[y]);
                }
                catch (Exception e)
                {
                    Console.WriteLine("\n\n Ops... Algo Errado Aconteceu!\n {0}", e);
                }
            }

            // Tiramos as Gorduras....
            meuAL.TrimToSize();
            Console.WriteLine("\n5- Tiramos as gorduras\n   Agora o ArrayList.Capacity é: {0}\n", meuAL.Capacity);

            // A propriedade Count contém o número de elementos
            Console.WriteLine("6- ArrayList.Count ainda é: {0} \n", meuAL.Count);

            // Imprimimos os valores dos elementos na tela novamente
            for (int y = 0; y < meuAL.Count; y++)
            {
                try
                {
                    Console.WriteLine("O índice {0} = {1}", y, (int)meuAL[y]);
                }
                catch (Exception e)
                {
                    Console.WriteLine("\n\n Ops... Algo Errado Aconteceu!\n {0}", e);
                }
            }
        } // END MAIN
    } // END CLASS PROGRAM
}// END NAMESPACE#

Esse foi só um exemplo! Se tiverem com tempo brinquem com o Object Browser e procurem saber como funciona os seguintes métodos, eles são bem interessantes…

• insert();
• remove();
• removeAt();
• removeRange();
• getRange();
• toArray();
• sort();
• reverse();

Abraços…

Olá a todos,

é verdade depois de um tempo todo mundo aparece… fiquei sem fazer posts nesses últimos dias porque por enquanto eu trabalho com um chefe maluco que joga 3 projetos para eu Administrar, Programar, Criar a Modelagem e Colocar em Produção em apenas 1 mês!

Definitivamente acabou com minha vida, e pra completar vou ter que viajar pra Angola no dia 6 de setembro… é a vida, mas vamos ao que interessa… Arrays em C#!

Bem.. a maioria das pessoas que já desenvolveram podem pular esse paragrafo. O array nada mais é uma seqüência de elementos do mesmo tipo, esses elementos são acessados por um índice do tipo int.

Em questão de memória o Array residem em um bloco contíguo da memória e são tipo-referência, em questão de OO Array também é uma classe, como sempre volto a repetir.. quer saber mais sobre tal classe, interface e etc.? Procure no Object Browser no seu Visual Studio 2008 “CTRL+W, J”.

Declarando e Instânciando Array

A declaração de um array é feito especificando o nome do tipo de elemento seguido por um par de colchetes “[]” e o nome do próprio array:

int[] motosID;

Como toda boa classe sem você instância-la você não faz nada! precisamos criar o objeto. Para instancia-lo utiliza-se a keyword new com o tipo do array seguido com o tamanho dentro de colchetes… Instanciar um array também inicializa seus valores padrões (0, null ou false dependendo do tipo do array)

motosID = new int[9]; // instância o array motos com o tamanho 10 (os índices iniciam contando do 0)
/* Você também pode inicializar, instanciar e definir os valores ao mesmo tempo */
int[] motosID = { 10, 11, 12, 13, 14, 15, 16 };

Também é possível criar Arrays multidimensionais, mas esse não é o objetivo desse artigo.

Você também pode criar Arrays utilizando estruturas (structs) e classe como o tipo do Array.

public class Moto{
// ...
    public Moto(){
        //Construtor padrão
    }
<pre>    public Moto(string nomeMoto){
        //Construtor com argumento
    }</pre>
}

Moto[] intruder = new Moto[1] { new Moto("Intruder125cc"), new Moto("Intruder250cc") };
/* Você pode usar o construtor da classe para iniciar os valores do array */

Iniciando um Array sem Tipo

Muitas vezes você não sabe qual vai ser o tipo do array à ser utilizado, porém você ainda precisa declara-lo… com isso o C# pode “adivinhar” o tipo dos valores que estão sendo utilizados.

var carros = new[]{"Palio", "Siena", "Punto"};

As novidades aqui são: a palavra-chave “var”; a omissão dos colchetes após o tipo (porque não existe tipo aqui ao declarar); a utilização do operador new e os colchetes antes da lista inicializadora.

Para utilizar esse recurso infelizmente você tem que assegurar que todos os valores do array serão iguais se no exemplo acima se eu colocasse depois do punto um valor int você obteria um erro.

Caso os valores sejam compatíveis o compilador converte automaticamente os valores, exemplo:

var numeros = new[]{5, 6, 7, 8, 9, 9.5, 9.6, 9.9, 10} // nesse caso o array não será int mas sim double

Talvez agora para você um array não tipado pode não ter muito sentido, eles são mais úteis utilizados em conjunto com tipos anônimos, mas isso é assunto para outro post.

Acessando Elementos no Array

Agora que já aprendemos a criar um array, precisamos recuperar os valores armazenados lá dentro.

int[] numeros = {1, 2, 3, 4, 5};
Console.WriteLine(numeros[0]); // O valor 1 será impresso na sua tela
//vamos modificar o valor daquela posição do array
numeros[0] = 11;
Console.WriteLine(numeros[0]); // O valor 11 será impresso na sua tela

Como nós sabemos que pode exestir problemas como em qualquer ciração feita pelo ser humano, alguém pode requisitar um índice de acesso que não existe, para isso temos que tratar o erro:

try{
    int[] numeros = {1, 2, 3, 4, 5};
    Console.WriteLine(numeros[5]);
} catch (IndexOutOfRangeException e){
 // código para  tratar o erro
}

Não só isso mas existe a necessidade também de percorremos um array inteiro, claro que para isso podemos utilizar o famoso FOR!!!

int[] numeros = {5, 6, 7, 8, 9, 10,, 11, 12, 13, 14, 15};

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

Length é uma propriedade e não um array, por isso não é utilizados colchetes “()” ao acessa-lo. Lembre-se que o índice do array começa com zero então a última posição é Length – 1. Você também pode utilizar o foreach para percorrer um elemento.

int numeros = {5, 6, 7, 8, 9, 10,, 11, 12, 13, 14, 15};
foreach (int numero in numeros){
Console.WriteLine(numero);
}

O foreach declara uma variável de iteração (neste caso o inteiro numero) que recebe cada valor do Array numeros e executa as instruções seguintes, em primeira vista isso é maravilhoso para percorrer, mas infelizmente você fica limitado:

1. Percorrer apenas em uma parte do Array, ou pular certos elementos. O foreach percorre ele todo obrigatóriamente
2. Percorrer o Array de trás para frente, o foreach percorre o Array sempre do 0 à Lenght -1
3. Se o corpo do loop necessita saber o índice ao invéz do valor atual.
4. Se você precisar alterar o valor de um elemento no array também ficará limitado
5. Etc.

Copiando Arrays

Como um array é um tipo-referência uma variável Array possui uma referência a uma instância do Array, isso quer dizer que ao copiar um Array você acaba copiando a referência e não o Array em si próprio.

int[] inteiros = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11};
int[] inteirosSegundo = inteiros;

O problema desse exemplo acima, é que se você modificar alguma valor no Array do inteirosSegundo você estará modificando o valor do Array ponteiros, e vice-versa…

Para copiar o Array é necessário criar outro Array do mesmo tipo e com o mesmo tamanho e criar um FOR para percorrer os valores do Array para o outro Array a ser copiado, exemplo:

int[] inteiros = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11};
int[] inteirosCopy = new  int[inteiros.Length];

for(int i = 0; i < inteiros.Length; i++){
inteirosCopy[i] = inteiros[i];
}

O legal é que a classe System.Array nos fornece alguns métodos legal, e dentre elas é CopyTo() que copia os valores de um Array para outro partindo de um determinado índice.

int[] inteiros = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11};
int[] inteirosCopy = new int[inteiros.Length];
inteiros.CopyTo(inteirosCopy, 0);

Um detalhe é que esse método é estático, então você pode utilizar esse método a partir da própria classe System.Array.

int[] inteiros = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11};
int[] inteirosCopy = new int[inteiros.Length];
Array.CopyTo(inteiros, inteirosCopy, inteirosCopy.Length);

Para mais detalhes de uma olhada no Object Browser do seu Visual Studio.

Você também tem o método Clone no seu objeto de Array ele retorna um object, para copiar os valores é necessário fazer um casting (casting será abordado em outro post, aguardem)

Boa sorte!