Array, Liste e Collection

Il Framework .Net mette a disposizione del programmatore un vasto numero di oggetti per manipolare insiemi di dati. Le classi a cui ci riferiamo sono: Array, ArrayList, HastTable, Queue, Stack, SortedList ed altre ancora. Queste classi si basano sulle interfacce: ICollection, IList, IDictionary e IEnumerable. E' assurdo pensare di imparare a memoria un gran numero di classi con i relativi metodi e proprieta'. Il primo passo da fare e' capire la strategia di gestione degli insiemi che sta dietro al progetto delle Collection. Avremo, cosi', una chiave per saper scegliere la classe che si adatta maggiormente alle nostre esigenze. In effetti, le guide di riferimento sono inutili o addirittura fuorvianti, per chi non sa' cosa cercare.

IEnumerator:

Un enumeratore e' un oggetto che permette di iterare su un intero insieme per visitare gli elementi uno ad uno. Se un'insieme implementa l'enumeratore, allora e' possibile applicarvi il ciclo For Each... Next.

• Current - Fornisce l'elemento corrente dell'enumerazione.
• MoveNext - Si porta all'elemento successivo dell'enumerazione.
• Reset - Inizializza l'enumerazione.

IEnumerable:

Un oggetto che implementa IEnumerable e' in grado di fornire un enumeratore per l'insieme che rappresenta.

• GetEnumerator - Restituisce l'enumeratore dell'insieme.

ICollection:

Implementa IEnumerable e definisce enumeratori, dimensione e sincronizzazione per un insieme di elementi.

• Count - Restituisce il numero di elementi contenuti nell'oggetto.
• IsSynchonized - Indica se la collection e' Thread Safe.
• SyncRoot - Se l'oggetto e' Thread Safe, fornisce un oggetto di sincronizzazione.
• CopyTo - Trasferisce gli elementi in un array.

IList:

Implementa ICollection, IEnumerable per rappresentare un insieme di oggetti accessibili individualmente tramite un indice.

• Item - Permette di accedere al singolo elemento tramite un indice.
• Add - Aggiunge un elemento.
• Clear - Elimina tutti gli elementi.
• Contains - Indica se e' presente un dato elemento.
• IndexOf - Restituisce la posizione dell'elemento dato.
• Insert - Inserisce un elemento alla posizione data.
• Remove - Elimina la prima occorrenza dell'elemento dato.
• RemoveAt - Elimina l'elemento alla posizione data.

IDictionary:

Implementa ICollection, IEnumerable e definisce una collection i cui elementi memorizzano delle chiavi a ciascuna delle quali e' associato un valore.

• Item - Permette di accedere ad un singolo elemento tramite una chiave.
• Keys - Restituisce l'insieme di chiavi.
• Values - Restituisce l'insieme di valori memorizzati.
• Add - Aggiunge un elemento contraddistinto da una chiave ed un valore.
• Clear - Elimina tutti gli elementi.
• Contains - Testa la presenza di un elemento che ha la chiave data.
• Remove - Elimina l'elemento associato alla chiave data.

Adesso che conosciamo le basi dei vari tipi di oggetti che rappresentano insiemi, passiamo ad analizzarli evidenziando le caratteristiche che li differenziano gli uni dagli altri:

Array:

Deriva da ICloneable, IList, ICollection, IEnumerable e rappresenta un insieme ordinato di elementi, accessibili per indice.

• Lenght - Restituisce il numero di elementi.
• Rank - Restituisce il numero di dimensioni.
• GetLenght - Restituisce il numero di elementi della dimensione specificata.
• IndexOf - Restituisce la posizione della prima occorrenza dell'elemento specificato.
• LastIndexOf - Restituisce la posizione dell'ultima occorrenza dell'elemento specificato.
• Reverse - Inverte l'ordine degli elementi di un array unidimensionale.
• Sort - Ordina gli elementi di un array unidimensionale.

    Sub esempio_array()
        System.Console.WriteLine("Array -------------------------------")
        Dim a() As Integer = {4, 3, 7, 4, 8} 
        Dim i As Integer

        System.Console.WriteLine("Totale elementi: {0}", a.Length())

        System.Console.Write("Elementi:")
        For i = 0 To a.Length() - 1
            System.Console.Write(" " & a(i))
        Next
        System.Console.WriteLine()

        System.Console.WriteLine("Prima occorrenza di 4: {0}", _
			Array.IndexOf(a, 4))
        System.Console.WriteLine("Ultima occorrenza di 4: {0}", _
			Array.LastIndexOf(a, 4))

        System.Console.Write("Metodo Reverse:")
        Array.Reverse(a)
        For i = 0 To a.Length() - 1
            System.Console.Write(" " & a(i))
        Next
        System.Console.WriteLine()

        System.Console.Write("Metodo Sort:")
        Array.Sort(a)
        For i = 0 To a.Length() - 1
            System.Console.Write(" " & a(i))
        Next
        System.Console.WriteLine()

    End Sub

ArrayList:

Deriva da IList, ICollection, IEnumerable e rappresenta un array la cui capacita' si ridimensiona all'occorrenza.

• Capacity - Mostra la capacita' attuale.
• AddRange - Accoda un insieme di elementi alla lista.
• InsertRange - Inserisce un insieme di elementi a partire da una data posizione.
• RemoveRange - Elimina un insieme di elementi.
• IndexOf - Restituisce la prima occorrenza dell'elemento specificato.
• LastIndexOf - Restituisce l'ultima occorrenza dell'elemento specificato.
• Sort - Ordina gli elementi.

    Sub esempio_arraylist()
        System.Console.WriteLine("ArrayList ---------------------------")
        Dim a As New ArrayList(2)
        System.Console.Write("Capacita': {0}, ", _
			a.Capacity)
        System.Console.WriteLine("Numero di elementi: {0}", a.Count)

        a.Add("verde")
        a.Add("Giallo")
        a.Add("blue") 

        System.Console.Write("Elementi aggiunti: ")
        Dim sItem As String
        For Each sItem In a 
            System.Console.Write(" " & sItem)
        Next 
        System.Console.WriteLine()

        System.Console.Write("Capacita': {0}, ", a.Capacity)
        System.Console.WriteLine("Numero di elementi: {0}", a.Count)

        a.Sort() 
        System.Console.Write("Elementi ordinati: ")
        Dim e As IEnumerator 
        e = a.GetEnumerator 
        Do While e.MoveNext
            System.Console.Write(" " & e.Current)
        Loop
        System.Console.WriteLine()

    End Sub
		

Queue:

Deriva da ICollection, IEnumerable. Una Queue e' un insieme di elementi nel quale s'inserisce in coda e si estrae in testa, cioe' il primo elemento che entra e' il primo ad uscire, First In, First Out (FIFO).

In: e6 --> |e5|e4|e3|e2|  --> Out: e1

• Enqueue - Accoda un elemento.
• Dequeue - Estrae il primo elemento della coda.
• Peek - Restituisce il prossimo elemento, senza estrarlo.

    Sub esempio_queue()
        System.Console.WriteLine("Queue -------------------------------")
        Dim q As New Queue() 
        System.Console.WriteLine("Inserisco: {0}", "Primo")
        q.Enqueue("Primo") 
        System.Console.WriteLine("Inserisco: {0}", "Secondo")
        q.Enqueue("Secondo") 
        System.Console.WriteLine("Inserisco: {0}", "Terzo")
        q.Enqueue("Terzo") 

        System.Console.WriteLine("Estraggo: {0}", q.Dequeue())
        System.Console.WriteLine("Estraggo: {0}", q.Dequeue())
        System.Console.WriteLine("Estraggo: {0}", q.Dequeue())
    End Sub

		

Stack:

Deriva da ICollection, IEnumerable. Uno Stack inserisce l'elemento in testa ed estrae l'elemento in testa, cioe' l'ultimo elemento inserito e' il primo ad uscire, Last In, First Out (LIFO).

|e1|e2|e3|e4|  <-- In: e5
|e1|e2|e3|e4|  --> Out: e4

• Push - Spinge un elemento in testa allo stack.
• Pop - Estrae l'elemento in testa allo stack.
• Peek - Restituisce l'elemento di testa, senza estrarlo.

    Sub esempio_stack()
        System.Console.WriteLine("Stack -------------------------------")
        Dim s As New Stack() 
        System.Console.WriteLine("Inserisco: {0}", "Primo")
        s.Push("Primo") 
        System.Console.WriteLine("Inserisco: {0}", "Secondo")
        s.Push("Secondo") 
        System.Console.WriteLine("Inserisco: {0}", "Terzo")
        s.Push("Terzo") 

        System.Console.WriteLine("Estraggo: {0}", s.Pop())
        System.Console.WriteLine("Estraggo: {0}", s.Pop())
        System.Console.WriteLine("Estraggo: {0}", s.Pop())
    End Sub

HashTable:

Deriva da IDictionary, ICollection, IEnumerable e fornisce una collection di elementi identificati da una coppia chiave-valore. Ogni elemento e' univocamente individuabile tramite la chiave.

• Keys - Fornisce l'insieme delle chiavi memorizzate.
• Values - Fornisce l'insieme dei valori memorizzati.
• Add - Aggiunge una coppia chiave, valore.
• Clear - Elimina tutti gli elementi.
• Remove - Elimina l'elemento con la chiave data.
• ContainsKey - Verifica l'esistenza della chiave specificata.
• ContainsValue - Verifica l'esistenza del valore specificato.

    Sub esempio_hashtable()
        System.Console.WriteLine("HashTable ---------------------------")
        Dim eta As New Hashtable() 
        eta.Add("Carlo", 18) 
        eta.Add("Sonia", 26) 
        eta.Add("Davide", 24) 
        eta.Add("Erica", 7) 

        System.Console.WriteLine("Davide ha {0} anni", _
			eta("Davide"))

        Dim chiavi As ICollection = eta.Keys 
        Dim sKey As String
        For Each sKey In chiavi 
            System.Console.WriteLine(sKey & " ha {0} anni", eta(sKey))
        Next 

    End Sub