Lekce 8: Pole a kolekce – Uchovávání více hodnot v C#

V programování často potřebujeme pracovat s více hodnotami stejného typu, které je vhodné nějakým způsobem organizovat a zpracovávat najednou. Místo toho, abychom vytvářeli proměnnou pro každou hodnotu, můžeme použít pole nebo kolekce. Pole a kolekce nám umožňují efektivně pracovat s více hodnotami pomocí jednoho strukturovaného typu. V této lekci se zaměříme na to, jak pole a kolekce fungují v C#, jak je používat, a jaké jsou rozdíly mezi nimi.

Co je pole?

Pole je datová struktura, která uchovává pevný počet prvků stejného typu. Prvky v poli jsou umístěny v paměti za sebou a přístup k nim je možný pomocí indexů, které začínají hodnotou 0. Pole jsou v C# velmi užitečné, když potřebujeme uchovávat větší množství hodnot a mít k nim rychlý a efektivní přístup.

Deklarace pole

V C# deklarujeme pole tím, že uvedeme typ dat, které bude pole uchovávat, následovaný hranatými závorkami. Pak můžeme pole inicializovat s pevnou velikostí nebo rovnou přiřadit hodnoty.

int[] cisla = new int[5];  // Pole pro pět celých čísel

V tomto příkladu deklarujeme pole cisla, které je schopno uchovávat pět prvků typu int. Pole bylo inicializováno, ale zatím neobsahuje žádné konkrétní hodnoty. Pokud bychom chtěli pole ihned naplnit, můžeme použít následující zápis:

int[] cisla = { 1, 2, 3, 4, 5 };  // Inicializace pole s pěti hodnotami

Přístup k prvkům pole

K jednotlivým prvkům pole přistupujeme pomocí indexů. První prvek má vždy index 0, druhý prvek index 1, a tak dále.

cisla[0] = 10;  // Změna hodnoty prvního prvku na 10
int hodnota = cisla[2];  // Přiřazení hodnoty třetího prvku do proměnné

Iterace přes pole

Pokud chceme projít všechny prvky pole, můžeme použít smyčku for nebo foreach. Smyčka for nám umožňuje iterovat přes pole pomocí indexů, zatímco foreach iteruje přímo přes hodnoty pole, což je často jednodušší pro čtení.

for (int i = 0; i < cisla.Length; i++)
{
    Console.WriteLine(cisla[i]);  // Výpis všech hodnot z pole
}

foreach (int hodnota in cisla)
{
    Console.WriteLine(hodnota);  // Výpis všech hodnot z pole (foreach smyčka)
}

Jednodimenzionální a vícedimenzionální pole

V C# můžeme vytvořit nejen jednoduchá jednodimenzionální pole, ale také pole s více dimenzemi, známá jako vícedimenzionální pole. Tato pole se používají k reprezentaci složitějších struktur, jako jsou matice nebo tabulky.

Vícedimenzionální pole

Vícedimenzionální pole se deklarují s více sadami hranatých závorek. Například dvourozměrné pole může být reprezentováno jako matice řádků a sloupců.

int[,] matice = new int[3, 3];  // Dvourozměrné pole 3x3
matice[0, 0] = 1;  // První prvek v první řádce a prvním sloupci

Iterace přes vícedimenzionální pole

Při práci s vícedimenzionálními poli obvykle potřebujeme použít zanořené smyčky, abychom prošli všechny řádky a sloupce.

for (int i = 0; i < 3; i++)  // Iterace přes řádky
{
    for (int j = 0; j < 3; j++)  // Iterace přes sloupce
    {
        Console.WriteLine(matice[i, j]);  // Výpis hodnot
    }
}

Kolekce v C#

Pole mají pevnou velikost, což může být někdy omezující. Pokud potřebujeme dynamicky měnit velikost struktury, můžeme použít kolekce. Kolekce jsou pružnější než pole, protože mohou dynamicky přidávat a odebírat prvky.

ArrayList

Jednou z nejjednodušších kolekcí v C# je ArrayList. Tato kolekce umožňuje přidávat, odebírat a měnit prvky bez nutnosti předem stanovit velikost.

using System.Collections;

ArrayList seznam = new ArrayList();
seznam.Add(10);  // Přidání prvku
seznam.Add(20);  // Přidání dalšího prvku
Console.WriteLine(seznam[0]);  // Výstup: 10

ArrayList může uchovávat prvky různých datových typů, ale kvůli tomu ztrácíme typovou bezpečnost, což může vést k chybám. Proto se dnes doporučuje používat generické kolekce.

Generické kolekce – List<T>

Generické kolekce, jako je List<T>, umožňují vytvoření typově bezpečné kolekce. Můžeme specifikovat, jaký datový typ kolekce bude obsahovat, čímž eliminujeme chyby spojené s typovou nekompatibilitou.

List<int> seznam = new List<int>();
seznam.Add(10);  // Přidání prvku
seznam.Add(20);  // Přidání dalšího prvku
Console.WriteLine(seznam[0]);  // Výstup: 10

V tomto případě List<int> může obsahovat pouze hodnoty typu int.

Práce s kolekcemi

Stejně jako u polí můžeme iterovat přes kolekce pomocí smyčky for nebo foreach. Kolekce navíc poskytují mnoho užitečných metod pro práci s prvky, jako je přidávání, mazání nebo hledání prvků.

List<string> jmena = new List<string> { "Petr", "Anna", "Josef" };

foreach (string jmeno in jmena)
{
    Console.WriteLine(jmeno);  // Výpis: Petr, Anna, Josef
}

Rozdíly mezi polem a kolekcemi

Efektivní práce s kolekcemi

Při práci s kolekcemi je důležité zvážit, jaké operace budeme nejčastěji provádět. Pro různé typy operací existují různé typy kolekcí:

• List<T>: Ideální pro dynamicky se měnící seznamy, kde často přidáváme a odebíráme prvky.
• Dictionary<TKey, TValue>: Umožňuje efektivně ukládat páry klíč-hodnota a rychle hledat hodnoty na základě klíčů.
• Queue<T>: Reprezentuje frontu, kde jsou prvky přidávány na konec a odebírány z počátku (FIFO).
• Stack<T>: Reprezentuje zásobník, kde jsou prvky přidávány i odebírány z vrcholu (LIFO).

Každý typ kolekce má své výhody a je vhodný pro různé scénáře.

Závěr

Pole a kolekce jsou nezbytnými nástroji pro uchovávání a správu více hodnot v C#. Pole jsou skvělá pro pevně dané množství hodnot, zatímco kolekce poskytují větší flexibilitu pro práci s dynamickými daty. Použití správného typu datové struktury je klíčové pro efektivitu a správnou funkci aplikace. V této lekci jsme se naučili, jak pracovat s poli, vícedimenzionálními poli a různými typy kolekcí v C#.