Ciljevi lekcije:

  • Razumevanje i korišćenje sistemskih generičkih klasa za rad sa kolekcijama podataka.
  • Učenje o različitim vrstama generičkih kolekcija kao što su List<T>, Dictionary<TKey, TValue>, Stack<T>, Queue<T>, i HashSet<T>.
  • Razumevanje kako koristiti ove kolekcije za efikasno upravljanje podacima u aplikacijama.

Uvod:

C# i .NET pružaju bogat skup generičkih klasa koje su dizajnirane za rad sa kolekcijama i drugim uobičajenim strukturama podataka. Ove generičke klase olakšavaju rad sa različitim tipovima podataka, omogućavajući pisanje efikasnijeg, tipom sigurnog koda. One su deo System.Collections.Generic prostora imena.

Neke od najčešće korišćenih generičkih klasa uključuju List<T>, Dictionary<TKey, TValue>, Queue<T>, Stack<T>, i HashSet<T>.

Ključni pojmovi:

  • Generička klasa: Klasa koja može raditi sa bilo kojim tipom podataka putem parametara tipa.
  • Kolekcija: Grupa objekata koja je upravljana i organizovana na određeni način (npr. lista, red, stek).
  •  
  • Generičke kolekcije: Kolekcije koje koriste generičke tipove za skladištenje i manipulaciju podacima.
  • Tipovi kolekcija: Različiti tipovi kolekcija pružaju različite načine za pristupanje, dodavanje i uklanjanje podataka.
  •  

Osnovne sistemske generičke klase (generičke kolekcije u C#):

  1. List<T>:
    • Opis: List<T> je dinamička kolekcija koja se može proširivati i smanjivati prema potrebi. Drugim rečima: Lista koja omogućava dinamičko dodavanje i uklanjanje elemenata. Nalikuje nizu, ali može da raste i da se smanjuje.
    • Primer 1:
List<int> numbers = new List<int>();
numbers.Add(1);
numbers.Add(2);
numbers.Add(3);
Console.WriteLine(numbers[0]); // Output: 1

    • Primer 2:
 
List<string> names = new List<string>();
names.Add("Pera");
names.Add("Sima");
names.Add("Cvrle");

foreach (var name in names)
{
Console.WriteLine(name);
}

slika gde su prikazane metode i propertiji Lista u C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication5
{
    class Program
    {
        static void Main(string[] args)
        {  
            List<int> numbers = new List<int>();
            numbers.Add(1);
            numbers.Add(2);
            numbers.Add(3);
            Console.WriteLine(numbers[0]);  // Output: 1

            foreach (var pera in numbers)
            {
                Console.Write(pera + " ");
            }
            Console.WriteLine();
            Console.WriteLine("***************");

            List<string> names = new List<string>();
            names.Add("Pera");
            names.Add("Sima");
            names.Add("Cvrle");

            foreach (var name in names)
            {
                Console.WriteLine(name);
            }

            names.RemoveAt(2);
            Console.WriteLine("Nakon brisanja imamo:");
            foreach (var name in names)
            {
                Console.WriteLine(name);
            }

            Console.WriteLine("unesite novi element liste:");
            string novi = Console.ReadLine();
            names.Add(novi);
           
            foreach (var name in names)
            {
                Console.WriteLine(name);
            }
            Console.ReadLine();
        }
    }
}

2. Dictionary<TKey, TValue>
  • Opis: Kolekcija koja skladišti podatke u obliku parova ključ-vrednost. Ključevi su jedinstveni u kolekciji.
  • Primer:
Dictionary<string, int> ages = new Dictionary<string, int>();
ages["Alice"] = 30;
ages["Bob"] = 25;

foreach (var entry in ages)
{
Console.WriteLine(entry.Key + " : " + entry.Value);
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication6
{
    class Program
    {
        static void Main(string[] args)
        {   
            // rečnik - za svako ime vrednost je broj godina
            Dictionary<string, int> ages = new Dictionary<string, int>();
            ages["Alice"] = 30;
            ages["Bob"] = 25;

            foreach (var entry in ages)
            {
                 Console.WriteLine(entry.Key + "\t: "+ entry.Value);
            }
            Console.WriteLine("------------ separator  ------------- ");
            // za svaki broj da damo neku rečenicu
            Dictionary<int, string> izrazi = new Dictionary<int, string>();
            izrazi[100] = "Riba ribi grize rep";
            izrazi[1000] = "Hiljadu i jedna noć";
            izrazi[0] = " ";

            foreach (var item in izrazi)
            {
                Console.WriteLine(item.Key + "\t:" + item.Value);
            }
            Console.WriteLine("------------ ---------- ------------- ");
            // rečnik stranih reči
            Dictionary<string, string> pojmovi = new Dictionary<string, string>();
            pojmovi["pomidore"] = "paradajz";
            pojmovi["skaline"] = "stepenice";
            pojmovi["birtija"] = "kafana";
            foreach (var item in pojmovi)
            {
                 Console.WriteLine(item.Key + " : " + item.Value);
            }
        }
    }
}

3. Stack<T>
  • Opis: Kolekcija koja koristi princip Last-In-First-Out (LIFO), gde poslednji dodatni element je prvi koji se uklanja.
  • Primer:
 
Stack<int> stack = new Stack<int>();
stack.Push(1);
stack.Push(2);
stack.Push(3);

while (stack.Count > 0)
{
Console.WriteLine(stack.Pop());
}

4. Queue<T>
  • Opis: Kolekcija koja koristi princip First-In-First-Out (FIFO), gde prvi dodatni element je prvi koji se uklanja.
  • Primer:
 
Queue<string> queue = new Queue<string>();
queue.Enqueue("Task 1");
queue.Enqueue("Task 2");
queue.Enqueue("Task 3");

while (queue.Count > 0)
{
Console.WriteLine(queue.Dequeue());
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication7
{
    class Program
    {
        static void Main(string[] args)
        {
            Stack<int> stack = new Stack<int>();
            stack.Push(1);
            stack.Push(2);
            stack.Push(3);

            while (stack.Count > 0)
            {
                Console.WriteLine(stack.Pop());
            }
            Console.WriteLine("------------------------");
            
            Stack<string> stackReci = new Stack<string>();
            stackReci.Push("Riba");
            stackReci.Push("ribi");
            stackReci.Push("grize rep");

            while (stackReci.Count > 0)
            {
                Console.WriteLine(stackReci.Pop());
            }
            Console.WriteLine("--malo rada sa Queue (sa redom)--------");
            
            Queue<string> queue = new Queue<string>();
            queue.Enqueue("Task 1");
            queue.Enqueue("Task 2");
            queue.Enqueue("Task 3");

            while (queue.Count > 0)
            {
                Console.WriteLine(queue.Dequeue());
            }

            Queue<int> broj = new Queue<int>();
            broj.Enqueue(1);
            broj.Enqueue(10);
            broj.Enqueue(100);

            while (broj.Count > 0)
            {
                Console.WriteLine(broj.Dequeue());
            }

        }
    }
}

5. HashSet<T>
  • Opis: Kolekcija koja skladišti jedinstvene elemente i ne dozvoljava duplikate. Ne garantuje redosled elemenata.
  • Primer:
HashSet<int> set = new HashSet<int>();
set.Add(1);
set.Add(2);
set.Add(2); // Duplicitni element, neće biti dodat

foreach (var item in set)
{
Console.WriteLine(item);
}

Prednosti korišćenja generičkih kolekcija:

  • Fleksibilnost: Omogućavaju rad sa različitim tipovima podataka i automatsko prilagođavanje veličine kolekcije.
  • Sigurnost tipova: Sprečavaju greške vezane za tipove podataka omogućavajući kompajleru da proveri ispravnost tipova tokom kompajliranja.
  • Performanse: Pružaju efikasne načine za rad sa podacima, smanjujući potrebu za dodatnim operacijama kao što su kastovanje i konverzija tipova.

Vežbe za učenike:

  1. Kreiranje i rad sa List<T>:

    • Kreirati listu koja skladišti nazive proizvoda. Dodati proizvode, pronaći određeni proizvod i/ili obrisati proizvod iz liste.
  2. Rad sa Dictionary<TKey, TValue>:

    • Kreirati rečnik koji povezuje imena sa godinama. Dodati nekoliko parova ključ-vrednost, prikazati sve parove i/ili ažurirati vrednost za određeni ključ.
  3. Korišćenje Stack<T>:

    • Implementirati jednostavan algoritam koji koristi stek za obrnut redosled niza brojeva.
  4. Implementacija Queue<T>:

    • Napraviti aplikaciju koja simulira red čekanja za servis, koristeći red za dodavanje i uklanjanje zadataka.
  5. Rad sa HashSet<T>:

    • Kreirajte set koji skladišti brojeve. Dodati nekoliko brojeva, uključujući duplikate, i prikazati sve brojeve u setu.

Zaključak:

Generičke kolekcije u C# pružaju moćan i fleksibilan način za upravljanje podacima u aplikacijama. Razumevanje različitih vrsta kolekcija i njihovih primena omogućava efikasno i efektivno programiranje.

Pitanja za diskusiju:

  1. Koje su ključne razlike između List<T> i Dictionary<TKey, TValue>?
  2. Kada biste koristili Stack<T> umesto Queue<T>?
  3. Koje su prednosti HashSet<T> u poređenju sa List<T> za skladištenje jedinstvenih elemenata?

Last modified: Tuesday, 2 December 2025, 4:53 AM