Tablica. (Zbiór uporządkowany o ustalonym rozmiarze)

Mariusz Jurczenko Mariusz Jurczenko

Tablica. (Zbiór uporządkowany o ustalonym rozmiarze)

Tablica jest zindeksowanym zbiorem obiektów, wszystkich tego samego typu. Tablica jest dobra w przypadku przechowywania stałej liczby wartości lub referencji. Jest to jedna z podstawowych struktur danych, którą każdy programista C# musi opanować.

Tablice w C# charakteryzują się kluczowymi cechami:

  • Stały rozmiar – określony w momencie tworzenia
  • Określona kolejność – elementy mają konkretne indeksy (0, 1, 2…)
  • Homogeniczne dane – wszystkie elementy tego samego typu
  • Sekwencyjne przechowywanie – elementy w pamięci obok siebie
  • Szybki dostęp – dostęp do elementu w czasie O(1)

Jako przykład wyobraź sobie, że z jakiegoś powodu musimy przechowywać miesiące w roku. Jest dwanaście miesięcy i zawsze będzie dwanaście miesięcy to jest stały rozmiar, a miesiące mają również określoną kolejność.

Luty zawsze przychodzi po styczniu, marzec zawsze przychodzi po lutym, kwiecień zawsze przychodzi po marcu i tak dalej.

Kiedy używać tablic w C#?

Tablice sprawdzają się idealnie, gdy:

  • Znamy z góry liczbę elementów
  • Potrzebujemy szybkiego dostępu do elementów przez indeks
  • Pracujemy z danymi o stałej strukturze

Praktyczny przykład: miesiące w roku

Wyobraź sobie, że musisz przechować wszystkie miesiące w roku. To doskonały przypadek użycia tablicy:

  • Jest dokładnie 12 miesięcy (stały rozmiar)
  • Miesiące mają określoną kolejność (styczeń → luty → marzec…)

Jak utworzyć tablicę w C#?

Pojedynczy string vs tablica stringów

Pojedynczy string:

string january  =  = "January";

Tablica wszystkich miesięcy – chcemy wszystkie miesiące w roku, więc to dwanaście stringów, więc potrzebujemy kolekcji stringów.

string[] monthsOfYear = { 
                "January", 
                "February", 
                "March", 
                "April", 
                "May", 
                "June", 
                "July", 
                "August", 
                "September", 
                "October", 
                "November", 
                "December" 
            };

Kluczowe elementy składni

  1. Typ + nawiasy kwadratowe: string[] oznacza tablicę stringów
  2. Inicjalizacja nawiasami klamrowymi: { wartość1, wartość2, ... }
  3. Separatory: przecinki między elementami
  4. Zakończenie: średnik na końcu instrukcji

Ważne: Nawiasy kwadratowe [] informują kompilator, że deklarujesz tablicę, a nie pojedynczą zmienną.

Jak tworzyć tablice w C#

tablice w C# można inicjalizować na kilka różnych sposobów:

Sposób 1: Inicjalizacja z wartościami (najczęściej używany)

// Najprostszy sposób - kompilator automatycznie określa rozmiar
string[] fruits = { "Apple", "Banana", "Cherry", "Date" };

// Alternatywna składnia - identyczny wynik
string[] fruits2 = new string[] { "Apple", "Banana", "Cherry", "Date" };

Sposób 2: Tworzenie pustej tablicy o określonym rozmiarze

// Tablica 10 elementów - wszystkie początkowo null/0/false
string[] names = new string[10];
int[] numbers = new int[5];        // { 0, 0, 0, 0, 0 }
bool[] flags = new bool[3];        // { false, false, false }

Sposób 3: Inicjalizacja z określonym rozmiarem i wartościam

// Określamy rozmiar i podajemy wartości
int[] scores = new int[4] { 95, 87, 92, 78 };

Sposób 4: Tworzenie tablicy z pętli lub LINQ

// Generowanie tablicy z wartościami
int[] evenNumbers = Enumerable.Range(0, 10)
                             .Where(x => x % 2 == 0)
                             .ToArray();
// Wynik: { 0, 2, 4, 6, 8 }

Operacje na tablicach – praktyczne przykłady

Dostęp do elementów

string[] colors = { "Red", "Green", "Blue", "Yellow" };

// Odczyt elementów
string firstColor = colors[0];           // "Red"
string lastColor = colors[colors.Length - 1]; // "Yellow"

// Modyfikacja elementów
colors[1] = "Purple";                    // Zmiana "Green" na "Purple"

// Właściwości tablicy
int arrayLength = colors.Length;         // 4
Type elementType = colors.GetType().GetElementType(); // System.String

Iteracja przez tablicę

string[] cities = { "Warsaw", "Krakow", "Gdansk", "Wroclaw" };

// Sposób 1: foreach (najbardziej czytelny)
foreach (string city in cities)
{
    Console.WriteLine($"Miasto: {city}");
}

// Sposób 2: for z indeksem (gdy potrzebujemy indeks)
for (int i = 0; i < cities.Length; i++)
{
    Console.WriteLine($"Miasto {i + 1}: {cities[i]}");
}

// Sposób 3: LINQ (funkcjonalnie)
cities.Where(city => city.StartsWith("W"))
      .ToList()
      .ForEach(city => Console.WriteLine(city));

Zaawansowane techniki pracy z tablicami

Tablice wielowymiarowe w C#

// Tablica dwuwymiarowa (macierz)
int[,] matrix = new int[3, 3] {
    { 1, 2, 3 },
    { 4, 5, 6 },
    { 7, 8, 9 }
};

// Dostęp do elementu
int element = matrix[1, 2]; // 6

// Tablice postrzępione (jagged arrays)
int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int[4] { 1, 2, 3, 4 };
jaggedArray[1] = new int[2] { 5, 6 };
jaggedArray[2] = new int[3] { 7, 8, 9 };

Przydatne metody dla tablic

int[] numbers = { 64, 25, 12, 22, 11 };

// Sortowanie
Array.Sort(numbers);              // { 11, 12, 22, 25, 64 }

// Wyszukiwanie
int index = Array.IndexOf(numbers, 22);  // 2

// Odwracanie
Array.Reverse(numbers);           // { 64, 25, 22, 12, 11 }

// Kopiowanie
int[] copy = new int[numbers.Length];
Array.Copy(numbers, copy, numbers.Length);

// Sprawdzanie czy istnieje element
bool exists = Array.Exists(numbers, x => x > 50); // true

Najczęstsze błędy przy pracy z tablicami

❌ IndexOutOfRangeException

int[] array = { 1, 2, 3 };

// BŁĄD - indeks poza zakresem
// int value = array[3]; // Wyjątek!

// ✅ POPRAWNIE - sprawdzenie zakresu
if (index >= 0 && index < array.Length)
{
    int value = array[index];
}

❌ NullReferenceException

string[] names = new string[5]; // Wszystkie elementy to null

// BŁĄD - próba wywołania metody na null
// int length = names[0].Length; // Wyjątek!

// ✅ POPRAWNIE - sprawdzenie null
if (names[0] != null)
{
    int length = names[0].Length;
}

Korzyści z używania tablic

  • Wydajność: szybki dostęp do elementów O(1)
  • Prostota: intuicyjna składnia
  • Bezpieczeństwo typów: kompilator sprawdza zgodność typów
  • Pamięć: efektywne wykorzystanie pamięci

Kiedy NIE używać tablic?

Użyj List<T> zamiast tablicy gdy:

  • Nie znasz z góry liczby elementów
  • Często dodajesz/usuwasz elementy
  • Potrzebujesz elastyczności rozmiaru
// Zamiast tablicy o nieznanym rozmiarze
// string[] userInputs = ???; // Ile elementów?

// Użyj List<T>
List<string> userInputs = new List<string>();
userInputs.Add("First input");
userInputs.Add("Second input");
// Rozmiar dostosowuje się automatycznie

Przykład praktyczny – System ocen studenta

public class StudentGradeSystem
{
    private readonly string[] subjects;
    private readonly double[] grades;
    
    public StudentGradeSystem()
    {
        // Przedmioty - stała lista, idealna dla tablicy
        subjects = { 
            "Mathematics", "Physics", "Chemistry", 
            "Biology", "History", "Literature" 
        };
        
        // Oceny odpowiadające przedmiotom
        grades = new double[subjects.Length];
    }
    
    public void SetGrade(string subject, double grade)
    {
        int index = Array.IndexOf(subjects, subject);
        if (index != -1 && grade >= 0 && grade <= 100)
        {
            grades[index] = grade;
        }
    }
    
    public double CalculateAverage()
    {
        return grades.Where(g => g > 0).Average();
    }
    
    public void DisplayGrades()
    {
        for (int i = 0; i < subjects.Length; i++)
        {
            Console.WriteLine($"{subjects[i]}: {grades[i]:F1}");
        }
        
        Console.WriteLine($"Average: {CalculateAverage():F2}");
    }
}

Podsumowanie – kiedy wybierać tablice w C#?

✅ Wybierz tablice gdy:

  • Znasz dokładną liczbę elementów
  • Potrzebujesz maksymalnej wydajności
  • Pracujesz z danymi o stałym rozmiarze
  • Zużycie pamięci jest krytyczne
  • Implementujesz algorytmy matematyczne

❌ Unikaj tablic gdy:

  • Rozmiar danych może się zmieniać
  • Często dodajesz/usuwasz elementy
  • Potrzebujesz zaawansowanych operacji (sortowanie, filtrowanie)
  • Pracujesz z danymi o zmiennej strukturze

Następne kroki w nauce kolekcji C#

Opanowałeś tablice? Czas na kolejne kolekcje:

  1. List<T> – elastyczna alternatywa dla tablic
  2. Dictionary<TKey, TValue> – szybkie wyszukiwanie po kluczu
  3. HashSet<T> – unikalne elementy i operacje zbiorów
  4. Queue<T> i Stack<T> – struktury FIFO/LIFO
  5. LINQ – funkcjonalne operacje na kolekcjach

Chcesz nauczyć się więcej o kolekcjach w C#?

Tablice to podstawowa, ale potężna struktura danych w C#. Idealne dla scenariuszy z określoną liczbą elementów i potrzebą szybkiego dostępu przez indeks. W kolejnych materiałach omówimy bardziej zaawansowane kolekcje jak List<T>, Dictionary<TKey, TValue> oraz struktury specjalistyczne jak Stack<T> i Queue<T>.

💡Chcesz wiecej... Chcesz opanować kolekcje w C#? Dołącz do kursu, gdzie przeprowadzę Cię przez esencję kolekcji w C# — od klasycznej tablicy, przez elastyczną listę, aż po sprytne struktury jak stos, kolejka i słownik. Nie tylko pokażę Ci jak ich używać, ale co ważniejsze — kiedy. Bo dobór kolekcji to nie przypadek, to świadoma decyzja architekta. Chcesz pisać kod, który nie tylko działa, ale ma klasę?

Dodaj komentarz

Twój adres e-mail nie zostanie opublikowany. Wymagane pola są oznaczone *