C# – Listák


Gyakorlatilag olyan, mint egy változó hosszúságú tömb. Konstruktora paraméter nélküli, bármilyen adattípusú változók tárolhatók bennük. Lista létrehozásakor beírjuk a List kulcsszót, közvetlenül utána az adattípust adjuk meg kisebb, nagyobb relációs jelek között, majd jön a lista neve (mi adjuk meg tetszőlegesen). Ezt követően jön az egyenlőségjel, a new List a típussal, végül a zárójelpár. Valahogy így:

List<int> Lista = new List<int> ()

vagy

List<string> Lista = new List<string> ()

vagy

List<double> Lista = new List<double> ()

A lista egy adott elemét úgy tudjuk elérni, hogy a neve után szögletes zárójelek között megadjuk a kívánt listaelem sorszámát (a számozás 0-val kezdődik). Például a 7. pozíción lévő elemet így érhetjük el:

Lista[6]

Tekintsük át, hogy a listáknál milyen hasznos függvényeket tudunk alkalmazni. A következő példákban végig olyan listát használok, melynek elemei számok. Természetesen szövegekre is igaz némelyik függvény. Értelemszerűen a Max( ) és Min( ) függvények például nem értelmezehtők szövegeken, de a Sort( ) függvény viszont igen.

Add( )

Elem hozzáadása a listához. Most az üres listához hozzáadjuk a 3-at, és kiíratjuk a lista nulladik elemét.

List<int> szamok = new List<int>();
szamok.Add(3);

Console.Write(szamok[0]); //3

AddRange( )

Több elem hozzáadása egyszerre. Az alábbi példában egy meglévő lista elemeihez hozzáadjuk egy másik lista összes elemét. Az új elemek a lista végére kerülnek.

List<int> szamok1 = new List<int>() {3, 5, 6, 10, 21 };
List<int> szamok2 = new List<int>() {9, 2, 4 };
szamok1.AddRange(szamok2);

foreach (var elem in szamok1)
{
Console.Write(” {0}”, elem); //3, 5, 6, 10, 21, 9, 2, 4
}

Remove ( )

Elem eltávolítása a listából. Ha az eredmény False, akkor az elem nincs a listában. Nézzük meg most ezt. A 10-et eltávolítjuk a listából. Ha nemlétező elemet adunk meg, a program akkor is lefut, az eredmény a teljes lista lesz, hiszen nem töröltünk ki semmit.

List<int> szamok = new List<int>() {3, 5, 6, 10, 21 };
szamok.Remove(10);

foreach (var elem in szamok)
{
Console.Write(” {0}”, elem); //3, 5, 6, 21
}

RemoveAt( )

Adott indexű elem eltávolítása a listából. A 2. pozícióban lévő elemet (6) eltávolítjuk! Ha nemlétező pozíciót adunk meg, akkor a program hibával megáll.

List<int> szamok = new List<int>() {3, 5, 6, 10, 21 };
szamok.Remove(szamok[2]);

foreach (var elem in szamok)
{
Console.Write(” {0}”, elem); //3, 5, 10, 21
}

RemoveAll( )

Egy listából eltávolítja azokat az elemeket, amelyek megfelelnek valamilyen feltételnek.

List<int> lista = new List<int>() { 35, 22, 7, 25, 8, 33 };
List<int> uj_lista = new List<int>();

Console.Write(“Az eredeti lista elemei:”);
foreach (var elem in lista)
{
Console.Write(” {0}”, elem); //35, 22, 7, 25, 8, 33
}

Console.Write(“\nNincs 23-nál nagyobb:\t”);
lista.RemoveAll(x => x > 23);
foreach (var elem in lista)
{
Console.Write(” {0}”, elem); //22, 7, 8
}

Clear( )

Lista kiürítése.

List<int> szamok = new List<int>() { 3, 5, 6, 10, 21 };
szamok.Clear();

foreach (var elem in szamok)
{
Console.Write(” {0}”, elem); //üres, nem ír ki semmit
}

Count( )

A listában lévő elemek számát adja meg.

List szamok = new List() { 3, 5, 6, 10, 21 };
int elemszam = szamok.Count();

Console.Write(“A listában lévő elemek száma: {0}”, elemszam); //5

Sort( )

A lista elemeit sorba rendezi.

List<int> szamok = new List<int>() { 21, 5, 10, 6, 2 };
szamok.Sort();

foreach (var elem in szamok)
{
Console.Write(” {0}”, elem); //2, 5, 6, 10, 21
}

Average( )

Ha valós számokat tartalmaz a lista, akkor kiszámolja ezek átlagát.

List<int> szamok = new List<int>() { 7, 13, 37, 5, 131 };
double atlag = szamok.Average();

Console.Write(“A listában szereplő számok átlaga: {0}”, atlag); //38,6

Min( ), Max( )

Ha a listában valós számok vannak, akkor megadják a legkisebb, illetve a legnagyobb elemet a listában.

List<int> szamok = new List<int>() { 7, 13, 37, 5, 131 };
double max = szamok.Max();
double min = szamok.Min();

Console.WriteLine(“A listában szereplő legnagyobb szám:\t{0}”, max); //131
Console.Write(“A listában szereplő legkisebb szám:\t{0}”, min); //5

Find( )

Egy listában megkereshetjük az első olyan elemet, ami megfelel egy feltételnek. Az alábbi példákon egy string és egy int típusú listákon láthatjuk a függvény használatát.

List<string> lista1 = new List<string>() { “alma”, “körte”, “dió”};
List<int> lista2 = new List<int>() { 15, 12, 7, 25, 17, 33 };

string elem1 = lista1.Find(x => x != “dió”);
string elem2 = lista1.Find(x => x == “dió”);
int elem3 = lista2.Find(x => x > 20);
int elem4 = lista2.Find(x => x <= 10);

Console.Write(“Az első, nem dió elem:\t\t{0}”, elem1); //alma
Console.Write(“\nAz első dió elem:\t\t{0}”, elem2); //dió
Console.Write(“\n\nAz első 20-nál nagyobb elem:\t{0}”, elem3); //25
Console.Write(“\nAz első 10-nél kisebb elem:\t{0}”, elem4); //7

FindAll( )

Egy listában megkereshetjük az összes olyan elemet, amelyek megfelelnek valamilyen feltételnek. Ezeket gyűjtsük ki egy új listába, és írassuk ki.

List<int> lista1 = new List<int>() { 15, 12, 7, 25, 17, 33 };
List<string> lista2 = new List<string>() { “alma”, “körte”, “dió”};
List<int> kisebb_husznal = new List<int>();
List<string> nem_dio = new List<string>();

Console.Write(“A 20-nál kisebb elemek:\t”);
kisebb_husznal = lista1.FindAll(x => x < 20);
foreach (var elem in kisebb_husznal)
{
Console.Write(” {0}”, elem); //15, 12, 7, 17
}

Console.Write(“\nA nem dió elemek:\t”);
nem_dio = lista2.FindAll(x => x != “dió”);
foreach (var elem in nem_dio)
{
Console.Write(” {0}”, elem); //alma, körte
}

FindIndex( )

Egy listában visszaadja annak az első elemnek az indexét, amelyik megfelel valamilyen feltételnek.

List<int> lista1 = new List<int>() { 35, 22, 7, 25, 17, 33 };
int kisebb_husznal = lista1.FindIndex(x => x < 10);
Console.Write(“Az első 10-nél kisebb szám indexe:\t{0}”, kisebb_husznal); //2

List<string> lista2 = new List<string>() { “körte”, “narancs”, “dió” };
int nem_korte = lista2.FindIndex(x => x != “körte”);
Console.Write(“\nAz első nem körte elem indexe:\t\t{0}”, nem_korte); //1

FindLast( )

Egy listában megadja az utolsó olyan elemt, amely megfelel valamilyen feltételnek.

List<int> lista1 = new List<int>() { 35, 22, 7, 25, 8, 33 };
int kisebb_husznal = lista1.FindLast(x => x < 20);
Console.Write(“Az utolsó 20-nál kisebb elem:\t{0}”, kisebb_husznal); //8

List<string> lista2 = new List<string>() { “körte”, “narancs”, “körte”, “dió”, “körte” };
string nem_korte = lista2.FindLast(x => x != “körte”);
Console.Write(“\nAz utolsó nem körte elem:\t{0}”, nem_korte); //dió

First( )

A lista első elemét adja vissza.

List<int> lista1 = new List<int>() { 35, 22, 7, 25, 8, 33 };
int elso_elem1 = lista1.First();
Console.Write(“A lista első eleme: {0}”, elso_elem1); //35

List<string> lista2 = new List<string>() { “alma”, “körte”, “dió” };
string elso_elem2 = lista2.First();
Console.Write(“\nA lista első eleme: {0}”, elso_elem2); //alma

Insert( )

Egy lista adott pozíciójába beszúrhatunk egy új elemet.

Console.Write(“A bővített számlista eredménye:\t\t”);
List<int> lista1 = new List<int>() { 35, 22, 7, 25, 8, 33 };
List<int> uj_lista = new List<int>();
Lista1.Insert(3, 19); //a 3. pozícióba beszúrtuk a 19-et
foreach (var elem in lista1)
{
Console.Write(” {0}”, elem); //35, 22, 7, 19, 25, 8, 33
}

Console.Write(“\nA bővített szöveglista eredménye:\t”);
List<string> lista2 = new List<string>() { “alma”, “körte”, “dió” };
lista2.Insert(1, “narancs”); //az 1. pozícióba beszúrtuk a narancs szöveget
foreach (var elem in lista2)
{
Console.Write(” {0}”, elem); //alma narancs körte dió
}

ToList( )

Befejezésül nézzünk meg még egy hasznos lehetőséget. A következő példában azt láthatjuk, hogy egy tömbből könnyen listát tudunk készíteni.

int[] tomb = {1, 2, 3, 4, 5 };
List lista = tomb.ToList();

Console.Write(“A tömb elemei:\t”);
foreach (var elem in tomb)
{
Console.Write(“{0} “, elem);
}

Console.Write(“\nA lista elemei:\t”);
foreach (var elem in lista)
{
Console.Write(“{0} “, elem);
}

Stringekkel is működik.

string[] tomb = {“tulipán”, “rózsa”, “szegfű”, “pipacs”, “gerbera”, “margaréta” };
List<string> lista = tomb.ToList();

Console.Write(“A tömb elemei:\t”);
foreach (var elem in tomb)
{
Console.Write(“{0} “, elem);
}

Console.Write(“\nA lista elemei:\t”);
foreach (var elem in lista)
{
Console.Write(“{0} “, elem);
}