Lista List_T_

Deși în limbajul C# există array-uri care stochează seturi de obiecte de același tip, nu întotdeauna este convenabil să lucrăm cu ele. De exemplu, un array stochează un număr fix de obiecte, dar ce facem dacă nu știm dinainte câte obiecte vom avea nevoie. În acest caz, este mult mai convenabil să folosim colecții.

Un alt avantaj al colecțiilor este că unele dintre ele implementează structuri de date standard, precum stiva, coada, dicționarul, care pot fi utile pentru rezolvarea diferitelor sarcini speciale. Majoritatea claselor de colecții sunt conținute în spațiul de nume System.Collections.Generic.

Clasa List<T> din spațiul de nume System.Collections.Generic reprezintă o listă simplă de obiecte de același tip. Clasa List este tipizată cu tipul ale cărui obiecte vor fi stocate în listă.

Putem crea o listă goală:

List<string> people = new List<string>();

În acest caz, obiectul List este tipizat cu tipul string. Asta înseamnă că putem stoca în această listă doar șiruri de caractere.

Putem inițializa lista cu valori inițiale chiar la momentul creării:

List<string> people = new List<string>() { "Tom", "Bob", "Sam" };

În acest caz, în listă sunt adăugate trei șiruri de caractere.

De asemenea, putem inițializa lista cu elemente dintr-o altă colecție, de exemplu, dintr-o altă listă:

var people = new List<string>() { "Tom", "Bob", "Sam" };
var employees = new List<string>(people);

Putem combina ambele metode:

var people = new List<string>() { "Tom", "Bob", "Sam" };
var employees = new List<string>(people) { "Mike" };

În acest caz, lista employees va avea patru elemente ({ "Tom", "Bob", "Sam", "Mike" }) - trei sunt adăugate din lista people și un element este specificat la inițializare.

Începând cu versiunea C# 12, pentru definirea listelor se pot folosi expresii de colecții, care presupun închiderea elementelor colecției între paranteze drepte:

List<string> people = ["Tom", "Bob", "Sam"];
List<string> employees = [];// listă goală

În mod similar, putem lucra cu liste de alte tipuri, de exemplu:

List<Person> people = new List<Person>()
{
   new Person("Tom"),
   new Person("Bob"),
   new Person("Sam")
};

class Person
{
   public string Name { get; }
   public Person(string name) => Name = name;
}

Stabilirea capacității inițiale a listei

Un alt constructor al clasei List primește ca parametru capacitatea inițială a listei:

List<string> people = new List<string>(16);

Stabilirea capacității inițiale a listei permite creșterea performanței și reducerea costurilor de alocare a memoriei la adăugarea de elemente. Deoarece adăugarea dinamică în listă poate duce la alocări suplimentare de memorie, ceea ce reduce performanța.

Dacă știm că lista nu va depăși o anumită dimensiune, putem transmite această dimensiune ca și capacitate a listei pentru a evita alocările suplimentare de memorie.

De asemenea, capacitatea inițială poate fi stabilită utilizând proprietatea Capacity, care este disponibilă în clasa List.

Accesarea elementelor listei

La fel ca array-urile, listele suportă indecși, prin care se poate accesa anumite elemente:

var people = new List<string>() { "Tom", "Bob", "Sam" };

string firstPerson = people[0]; // obținem primul element
Console.WriteLine(firstPerson); // Tom
people[0] = "Mike";     // modificăm primul element
Console.WriteLine(people[0]); // Mike

Lungimea listei

Cu ajutorul proprietății Count putem obține lungimea listei:

var people = new List<string>() { "Tom", "Bob", "Sam" };
Console.WriteLine(people.Count);    // 3

Parcurgerea listei

C# permite parcurgerea listei folosind ciclul standard foreach:

var people = new List<string>() { "Tom", "Bob", "Sam" };

foreach (var person in people)
{
   Console.WriteLine(person);
}
// Rezultatul programului:
// Tom
// Bob
// Sam

De asemenea, se pot folosi alte tipuri de cicluri și în combinație cu indecșii se pot parcurge listele:

var people = new List<string>() { "Tom", "Bob", "Sam" };

for (int i = 0; i < people.Count; i++)
{
   Console.WriteLine(people[i]);
}

Metodele listei

Dintre metodele sale, putem menționa următoarele:

void Add(T item): adăugarea unui nou element în listă
void AddRange(IEnumerable<T> collection): adăugarea unei colecții sau array în listă
int BinarySearch(T item): căutare binară a unui element în listă. Dacă elementul este găsit, metoda returnează indexul acestuia în colecție. Lista trebuie să fie sortată
void CopyTo(T[] array): copiază lista în array
void CopyTo(int index, T[] array, int arrayIndex, int count): copiază din listăîncepând de la index-ul index elementele al căror număr este egal cu count și le inserează în array începând de la arrayIndex
bool Contains(T item): returnează true dacă elementul item există în listă
void Clear(): șterge toate elementele din listă
bool Exists(Predicate<T> match): returnează true dacă în listă există un element care corespunde delegatului match
T? Find(Predicate<T> match): returnează primul element care corespunde delegatului match. Dacă elementul nu este găsit, returnează null
T? FindLast(Predicate<T> match): returnează ultimul element care corespunde delegatului match. Dacă elementul nu este găsit, returnează null
List<T> FindAll(Predicate<T> match): returnează o listă de elemente care corespund delegatului match
int IndexOf(T item): returnează indexul primei apariții a elementului în listă
int LastIndexOf(T item): returnează indexul ultimei apariții a elementului în listă
List<T> GetRange(int index, int count): returnează o listă de elemente al căror număr este egal cu count, începând de la indexul index
void Insert(int index, T item): inserează elementul item în listă la indexul index. Dacă nu există un astfel de index în listă, se generează o excepție
void InsertRange(int index, collection): inserează colecția de elemente collection în lista curentă începând de la indexul index. Dacă nu există un astfel de index în listă, se generează o excepție
bool Remove(T item): șterge elementul item din listă și returnează true dacă ștergerea a fost efectuată cu succes. Dacă în listă există mai multe elemente identice, se șterge doar primul dintre ele
void RemoveAt(int index): șterge elementul de la indexul specificat index. Dacă nu există un astfel de index în listă, se generează o excepție
void RemoveRange(int index, int count): parametrul index specifică indexul de la care trebuie șterse elementele, iar parametrul count specifică numărul de elemente care trebuie șterse
int RemoveAll((Predicate<T> match)): șterge toate elementele care corespund delegatului match. Returnează numărul de elemente șterse
void Reverse(): inversează ordinea elementelor
void Reverse(int index, int count): inversează ordinea pentru un număr de elemente egal cu count, începând de la indexul index
void Sort(): sortează lista
void Sort(IComparer<T>? comparer): sortează lista folosind obiectul comparer, care este transmis ca parametru

Adăugarea în listă

List<string> people = new List<string>() { "Tom" };

people.Add("Bob"); // adăugarea unui element
// people = { "Tom", "Bob" };

people.AddRange(new[] { "Sam", "Alice" });   // adăugăm un array
// people = { "Tom", "Bob", "Sam", "Alice" };
// am putea adăuga și o altă listă
// people.AddRange(new List<string>(){ "Sam", "Alice" });

people.Insert(0, "Eugene"); // inserăm pe prima poziție
// people = { "Eugene", "Tom", "Bob", "Sam", "Alice" };

people.InsertRange(1, new string[] {"Mike", "Kate"}); // inserăm un array de la indexul 1
// people = { "Eugene", "Mike", "Kate", "Tom", "Bob", "Sam", "Alice" };

// am putea adăuga și o altă listă
// people.InsertRange(1, new List<string>(){ "Mike", "Kate" });

Ștergerea din listă

var people = new List<string>() { "Eugene", "Mike", "Kate", "Tom", "Bob", "Sam", "Tom", "Alice" };

people.RemoveAt(1); // ștergem al doilea element
// people = { "Eugene", "Kate", "Tom", "Bob", "Sam", "Tom", "Alice" };

people.Remove("Tom"); // ștergem elementul "Tom"
// people = { "Eugene", "Kate", "Bob", "Sam", "Tom", "Alice" };

// ștergem din listă toate elementele a căror lungime este de 3 caractere
people.RemoveAll(person => person.Length == 3);
// people = { "Eugene", "Kate", "Alice" };

// ștergem din listă 2 elemente începând de la indexul 1
people.RemoveRange(1, 2);
// people = { "Eugene" };

// ștergem complet lista
people.Clear();
// people = {  };

Căutarea și verificarea elementelor

var people = new List<string>() { "Eugene", "Mike", "Kate", "Tom", "Bob", "Sam" };

var containsBob = people.Contains("Bob");     //  true
var containsBill = people.Contains("Bill");    // false

// verificăm dacă în listă există șiruri de caractere cu lungimea de 3 caractere
var existsLength3 = people.Exists(p => p.Length == 3);  // true

// verificăm dacă în listă există șiruri de caractere cu lungimea de 7 caractere
var existsLength7 = people.Exists(p => p.Length == 7);  // false

// obținem primul element cu lungimea de 3 caractere
var firstWithLength3 = people.Find(p => p.Length == 3); // Tom

// obținem ultimul element cu lungimea de 3 caractere
var lastWithLength3 = people.FindLast(p => p.Length == 3);  // Sam

// obținem toate elementele cu lungimea de 3 caractere sub formă de listă
List<string> peopleWithLength3 = people.FindAll(p => p.Length == 3);
// peopleWithLength3 { "Tom", "Bob", "Sam"}

Obținerea unui interval și copierea într-un array

List<string> people = new List<string>() {"Eugene", "Tom", "Mike", "Sam", "Bob" };

// obținem intervalul de la al doilea la al patrulea element
var range = people.GetRange(1, 3);
// range = { "Tom", "Mike", "Sam" };

// copiem în array primele trei elemente
string[] partOfPeople = new string[3];
people.CopyTo(0, partOfPeople, 0, 3);
// partOfPeople = { "Eugene", "Tom", "Mike" };

Inversarea ordinii elementelor

var people = new List<string>() { "Eugene", "Tom", "Mike", "Sam", "Bob" };

// inversăm întreaga listă
people.Reverse();
// people = { "Bob", "Sam", "Mike", "Tom", "Eugene" };

var people2 = new List<string>() { "Eugene", "Tom", "Mike", "Sam", "Bob" };
// inversăm doar 3 elemente începând de la indexul 1
people2.Reverse(1, 3);
// people2 = { "Eugene", "Sam", "Mike", "Tom", "Bob" };