Operazioni base sugli array monodimensionali

1. Introduzione

Cosa di solito vuoi fare con gli array?

Dai, elenchiamo le operazioni base:

• Lettura e modifica degli elementi dell'array tramite indice.
• Ricerca di un elemento tramite valore.
• Copiare un array, creare “slice” (una parte dell'array).
• Ordinare un array.
• Reverse (invertire) un array.
• Riempire un array con un valore.
• Verificare se un elemento esiste (se l'array contiene un certo valore).
• Cambiare la lunghezza (resize).

Nella vita reale ti capita spesso di fare queste cose — tipo, “c'è una somma sopra 4000?”, “trova il primo prezzo sotto 1000”, “ordina i prezzi in ordine crescente” e così via.

E per tutto questo abbiamo le funzioni

arr[n] = x

Array.IndexOf(arr, v)

Array.Exists(arr, pred)

Array.Sort(arr)

Array.Reverse(arr)

arr.Clone(), Array.Copy

Array.Fill(arr, val)

Array.Resize(ref arr, len)

arr.Max(), arr.Min()

2. Lettura e modifica degli elementi tramite indice

Questa la conosciamo già, ma fissiamola ancora una volta con un esempio semplice (supponiamo di avere un array di voti):

// Array dei voti dello studente
int[] grades = { 4, 3, 5, 2, 5 };

// Leggi il primo voto
int firstGrade = grades[0];
Console.WriteLine($"Primo voto: {firstGrade}");

// Cambia l'ultimo voto in "eccellente" (5)
grades[^1] = 5;
Console.WriteLine("Ultimo voto modificato: " + grades[^1]);

Qui è importante: l'indicizzazione parte da zero, se provi ad accedere a un indice che non esiste ottieni l'errore IndexOutOfRangeException — un classico sia ai colloqui che nella vita vera.

3. Ricerca di un elemento nell'array

Abbiamo due funzioni che cercano un elemento nell'array e restituiscono il suo indice se lo trovano.

Funzione Array.IndexOf(value [, from])

La funzione Array.IndexOf cerca l'elemento dato dall'inizio dell'array. Se lo trova, restituisce il suo indice. Se no — restituisce -1.

Ma che fai se vuoi trovare le occorrenze successive dello stesso elemento? Per questo, alla funzione Array.IndexOf devi passare il secondo parametro — l'indice da cui inizia a cercare. Deve essere l'indice dell'ultimo trovato + 1.

Troviamo tutte le occorrenze del numero 2 nel nostro array:

int[] grades = { 4, 3, 5, 2, 5, 2 };
int x = 2; // elemento che cerchiamo

int index = Array.IndexOf(grades, x);
while (index != -1)
{
    Console.WriteLine($"Elemento {x} trovato alla posizione: {index}");
    // Cerchiamo il prossimo indice, partendo da index + 1
    index = Array.IndexOf(grades, x, index + 1);
} 

Funzione Array.LastIndexOf(value [, from])

La funzione Array.LastIndexOf cerca l'elemento dato dalla fine dell'array. Se lo trova, restituisce il suo indice. Se no — restituisce -1. Per il resto è uguale a Array.IndexOf.

Troviamo tutte le occorrenze del numero 2 nel nostro array, ma cercando dalla fine:

int[] grades = { 4, 3, 5, 2, 5, 2 };
int x = 2; // elemento che cerchiamo

int index = Array.LastIndexOf(grades, x);
while (index != -1)
{
    Console.WriteLine($"Elemento {x} trovato alla posizione: {index}");
    // Cerchiamo il prossimo indice, partendo dalla posizione precedente - 1
    index = Array.LastIndexOf(grades, x, index - 1);
}

4. Verifica della presenza di un elemento nell'array

Per verificare se un elemento esiste c'è la funzione Contains. Questo metodo restituisce true se l'array contiene l'elemento dato. Per usarlo devi importare il modulo System.Linq. Esempio:

using System.Linq; // Aggiungi using System.Linq; se manca

bool hasExcellent = grades.Contains(5); 
Console.WriteLine($"C'è un cinque? {hasExcellent}");

Facilissimo e pulito.

5. Invertire un array: Array.Reverse

Mettiamo che vuoi invertire l'array “al contrario”. Usa:

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

// Invertiamo l'array
Array.Reverse(grades);
Console.WriteLine("Voti invertiti: " + string.Join(", ", grades));

Comodissimo per trovare i dati “più freschi” o se ti piace vedere il mondo sottosopra.

6. Ordinare un array: Array.Sort

Prima o poi ti verrà voglia di ordinare un array. Il modo più veloce e sicuro è usare la funzione standard di ordinamento:

int[] grades = { 4, 3, 5, 2, 5 };
// Ordiniamo in ordine crescente
Array.Sort(grades);
Console.WriteLine("Voti ordinati: " + string.Join(", ", grades));

Questa funzione ordina anche le stringhe, ma in ordine alfabetico.

Ordinamento decrescente

Lo standard Array.Sort ordina solo in modo crescente. Per ordinare in modo decrescente puoi usare sort + reverse:

Array.Sort(grades); // Prima in ordine crescente
Array.Reverse(grades); // Poi invertiamo
Console.WriteLine("In ordine decrescente: " + string.Join(", ", grades));

Nota: spesso ci si dimentica che l'ordinamento avviene “in place”: l'array viene modificato, non viene restituito uno nuovo. Se ti serve l'ordine originale, prima copia l'array di partenza.

7. Clonare un array: Clone e Array.Copy

Se vuoi fare una copia (e non rovinare l'array originale mentre lavori), usa i metodi Clone() e Array.Copy().

Il metodo Clone() lo chiami sull'array e ti restituisce una copia completa.

Il metodo Array.Copy() vuole che gli passi:

• l'array sorgente;
• l'array dove copiare i dati;
• quante celle copiare.

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

// Metodo 1: Clone()
// Funziona per array mono e multidimensionali, ma restituisce object, serve il type cast:
int[] copy1 = (int[]) original.Clone();

// Metodo 2: Array.Copy
int[] copy2 = new int[original.Length];
Array.Copy(original, copy2, original.Length);

Attenzione: gli array vengono copiati per valore se sono tipi primitivi (int, double). Se è un array di oggetti, vengono copiate solo le referenze! (cioè “copia superficiale”).

8. Riempire un array con un valore: Array.Fill

Vuoi “azzerare” un array o riempirlo tutto di cinque? Per questo c'è il metodo comodo — Array.Fill:

int[] grades = new int[5];
Array.Fill(grades, 5); // Ora tutti gli elementi sono 5
Console.WriteLine("Studente ipoteticamente perfetto: " + string.Join(", ", grades));

Utile quando devi inizializzare velocemente un array con un certo valore.

9. Ricerca del valore massimo e minimo

Il modulo System.Linq ha aggiunto un sacco di metodi utili agli array, e due di questi restituiscono il valore minimo e massimo nell'array. Si chiamano Max() e Min().

Troviamo il voto massimo o minimo nell'array:

int maxGrade = grades.Max();
int minGrade = grades.Min();
Console.WriteLine($"Voto massimo: {maxGrade}, minimo: {minGrade}");

Non dimenticare di aggiungere using System.Linq; per questi metodi.