C#

LIST

Si tratta di un'altra struttura dati molto utile e comoda, facente parte del namespace System.Collections.Generic (che dovete pertanto richiamare se volete usare le liste). In buona sostanza si tratta di un oggetto che contiene variabili ordinate (indicizzate) appartenti ad un certo tipo. le liste sono dinamiche, ovvero possono vedere modificate le proprie dimensioni. La particolarità rispetto agli ArrayList sta, come avrete notato, che gli elementi sono tutti di uno stesso tipo. In questo senso risultano essere dei veri e propri array dinamici.
La definizione formale per creare una lista vuota è la seguente:

List<tipo> nomelista = new List<tipo>();

Il metodo principe per aggiungere degli elementi è Add(elemento) che appende un nuovo elemento in coda a quelli esistenti (se non ce ne sono mette il primo, si capisce)

  Esempio 18.1
1
2
3
4
5
6
7
8
9
10
11
12
using System;
using System.Collections.Generic;

class program
{
  public static void Main()
  {
    List<int> list01 = new List<int>();
    list01.Add(3);
    list01.Add(4);
  }
}

L'esempio, molto basico, fa vedere come funzionano le cose.
Esistono altri due metodi di inizializzazione:
il primo permette di specificare un numero di elementi predefinito aggiungendo un intero che esprime appunto quel valore nella parte di destra:

List<tipo>(int32) 
ad esempio:
List<int> list01 = new List<int>(5);

Qui abbiamo creato una lista con una capacità predefinite ma sempre vuota.

Il secondo metodo ci permette invece inizializzare la nostra lista con una sequenza, che può essere di varia natura (deve implementare l'interfaccia IEnumerable, tecnicamente parlando) , già esistente e che naturalmente andrà specificata nella parte destra della definizione:

List<tipo>Sequenza
ad esempio:
List<int> list01 = new List<int>{1,2,3,4,5}

Ricordando che anche per questi costrutti si usa l'operatore [] per accedere ad un singolo elemento e che l'indicizzazione è 0-based, ovvero il primo indice è zero, vediamo un esempio un po' più completo:

  Esempio 18.2
1
2
3
4
5
6
7
8
9
10
11
12
13
using System;
using System.Collections.Generic;

class program
{
  public static void Main()
  {
    Console.Write("Inserisci una parola: ");
    string input = Console.ReadLine();
    List<char> list02 = new List<char>(input);
    Console.WriteLine(list02[2]);
  }
}

Il funzionamento è tutto qua. vediamo ora i metodi e le proprietà he è possibile usare sulle nostre liste.

Le proprietà sono:

Capacity, che indica il numero di elementi che la lista può accettare senza dover essere espansa (utile per verifiche sulle performance, ad esempio)
Count, che riporta il numero di elementi effettivamente contenuti.

  Esempio 18.3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
using System;
using System.Collections.Generic;

class program
{
  public static void Main()
  {
    Console.Write("Inserisci una parola: ");
    string input = Console.ReadLine();
    List<char> list02 = new List<char>(input);
    Console.WriteLine(list02.Capacity);
    Console.WriteLine(list02.Count);
  }
}

Molto più numerosi i metodi, dei quali riporto solo quelli di uso, a mio avviso, più frequente:

Add() lo abbiamo già introdotto e usato nell'esempio 18.1

Clear() rimuove tutti gli elementi dalla lista

Contains() determina se la lista contiene un certo elemento restituendo true o false.

IndexOf() restituisce l'indice della prima occorrenza di un certo elemento all'interno della lista. Se l'elemento non c'è viene retituito il valore -1. Potete usarlo in 3 formati:
--- quello proposto che analizza la lista dall'inizio alla fine
--- IndexOf(intero) che analizza la lista partendo dall'indice espresso dall'intero tra parentesi alla fine
--- IndexOf(intero, intero) che analizza la lista nell'intervallo che parte dal primo intero e analizza il numero degli elementi indicato dal secondo intero (in pratica IndexOf(indice, contatore))

Insert(indice, elemento) inserisce un elemento all'indice dato dal primo parametro.

LastIndexOf() restituisce l'ultima occorrenza dell'elemento cercato all'interno della lista. Anche qui abbiamo 3 formati:
--- quello proposto, che analizza la lista dall'inizio alla fine
--- LastIndexOf(intero) che analizza la lista partendo dall'indice specificato
--- LastiIndexOf(Intero, intero) che analizza  il numero di elementi specificato terminando all'indice specificato nel secondo intero

Remove() rimuove la prima occorrenza di un certo elemento

RemoveAt(int) rimuove l'elemento all'indice indicato

RemoveRange(int, Int) rimuove gli elementi nell'intervallo specificato dai due interi

Reverse() inverte gli elementi di una lista

Reverse(int, int) inverte gli elementi nell'intervallo specificato

Sort() ordina gli elementi di una lista

ToArray() riversa gli elementi di una lista in una matrice

Vediamo un esempio che vede in azioni alcuni di questi metodi. Contestualmente vedremo come navigare tra gli elementi di una lista, procedimento che dovreste comunque già intuire.

  Esempio 18.4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
using System;
using System.Collections.Generic;

class program
{
  public static void Main()
  {
    int[] input = new int[] {0,1,2,3,4,5,6,7,};
    List<int> list01 = new List<int>(input);
    Console.WriteLine("La lista contiene il numero 8? " + list01.Contains(8));
    Console.WriteLine("Indice del numero 6: " + list01.IndexOf(6));
    list01.Insert(4, 99);
    foreach (int item in list01)
    Console.Write(item + " ");
    Console.WriteLine();
    list01.Remove(7);
    list01.Sort();
    list01.Reverse();
    for (int x = 0; x < list01.Count; x++ )
    Console.Write(list01[x] + " ");
    int[] ar1 = list01.ToArray();
  }
}

L'esempio non dovrebbe presentare soverchie difficoltà di comprensione. I metodi per traversare una lista sono alla riga 13 e alla 19, ricordate che foreach è readonly.
Sul sito MSDN troverete altri metodi e ovviamente sul Web esistono esempi a vagonate.