List
</details>
Beskrivning
Vi använder olika typer av listor, för att slippa hantera Arrays :)
Vad är en lista?
En lista är en klass som implementerar en samling av objekt. Listan är en dynamisk samling av objekt, vilket innebär att den kan växa och minska i storlek. Detta är en stor fördel jämfört med en array, som har en fast storlek.
Listan är en klass som ärver från CollectionBase, vilket innebär att den har samma egenskaper som en array.
Vilka typer av listor finns det?
Det finns Arraylistor, LinkedListor och Generiska listor. Det finns även en Stack och en Queue, som är en specialiserad lista.
Absolut! Här är en fortsättning på artikeln om List med förklaringar och exempel med hjälp av Star Wars-hjältar:
Vad är en generisk lista?
En generisk lista är en typ av lista som tillåter hantering av objekt av vilken typ som helst. Genom att använda generiska listor kan du undvika behovet av att omvandla objekt till och från en specifik typ, vilket ger enklare och mer typsäker kod. I C-Sharp används den generiska List-klassen från System.Collections.Generic-namespace för att skapa generiska listor.
🔧 **List Properties och Methods**
Basic Properties
List<string> heroes = new List<string>{"Iron Man", "Thor", "Hulk"};
// Essential properties
Console.WriteLine($"Count: {heroes.Count}"); // 3 (antal element)
Console.WriteLine($"Capacity: {heroes.Capacity}"); // 4 (intern array storlek)
// Indexing - läsa och skriva
string first = heroes[0]; // "Iron Man"
heroes[1] = "Captain America"; // Ändra Thor -> Captain America
Lägg till element (Add Methods)
List<int> numbers = new List<int>();
// Add - lägg till ett element sist
numbers.Add(10); // {10}
numbers.Add(20); // {10, 20}
// AddRange - lägg till flera element sist
int[] moreNumbers = {30, 40, 50};
numbers.AddRange(moreNumbers); // {10, 20, 30, 40, 50}
// Insert - lägg till på specifik position
numbers.Insert(2, 25); // {10, 20, 25, 30, 40, 50}
// InsertRange - lägg till flera på specifik position
int[] insertNumbers = {22, 23};
numbers.InsertRange(2, insertNumbers); // {10, 20, 22, 23, 25, 30, 40, 50}
Ta bort element (Remove Methods)
List<string> fruits = new List<string>{"Äpple", "Banan", "Citron", "Druva", "Banan"};
// Remove - ta bort första förekomsten
fruits.Remove("Banan"); // {"Äpple", "Citron", "Druva", "Banan"}
// RemoveAt - ta bort på specifik position
fruits.RemoveAt(0); // {"Citron", "Druva", "Banan"}
// RemoveRange - ta bort flera element från position
fruits.RemoveRange(1, 2); // {"Citron"} - ta bort från index 1, antal 2
// RemoveAll - ta bort alla som matchar condition
List<int> scores = new List<int>{85, 92, 78, 96, 83, 91};
scores.RemoveAll(score => score < 85); // {85, 92, 96, 91}
// Clear - ta bort alla element
fruits.Clear(); // {}
Sök och hitta element (Find Methods)
List<int> numbers = new List<int>{10, 25, 30, 25, 45, 60};
// Contains - kontrollera om element finns
bool hasValue = numbers.Contains(25); // true
// IndexOf - hitta första förekomsten
int index = numbers.IndexOf(25); // 1
int notFound = numbers.IndexOf(99); // -1
// LastIndexOf - hitta sista förekomsten
int lastIndex = numbers.LastIndexOf(25); // 3
// Find - hitta första som matchar condition
int found = numbers.Find(x => x > 30); // 45
int notFoundValue = numbers.Find(x => x > 100); // 0 (default)
// FindIndex - hitta index för första som matchar
int foundIndex = numbers.FindIndex(x => x > 30); // 4 (index för 45)
// FindLast - hitta sista som matchar condition
int lastFound = numbers.FindLast(x => x > 30); // 60
// FindAll - hitta alla som matchar (returnerar ny lista)
List<int> large = numbers.FindAll(x => x >= 30); // {30, 45, 60}
// Exists - kontrollera om något matchar condition
bool hasLarge = numbers.Exists(x => x > 50); // true (60 > 50)
// TrueForAll - kontrollera om alla matchar condition
bool allPositive = numbers.TrueForAll(x => x > 0); // true
Sortering och ordning (Sort Methods)
List<int> numbers = new List<int>{5, 2, 8, 1, 9};
// Sort - sortera i stigande ordning (ändrar original!)
numbers.Sort(); // {1, 2, 5, 8, 9}
// Sort med custom comparison
numbers.Sort((a, b) => b.CompareTo(a)); // {9, 8, 5, 2, 1} - fallande
// Reverse - vänd ordning (ändrar original!)
numbers.Reverse(); // {1, 2, 5, 8, 9}
// För strings - sort ignorerar case
List<string> names = new List<string>{"anna", "Bert", "cilla"};
names.Sort(StringComparer.OrdinalIgnoreCase); // {"anna", "Bert", "cilla"}
Konvertering och transformation
List<string> names = new List<string>{"Anna", "Bert", "Cilla"};
// ToArray - konvertera till array
string[] nameArray = names.ToArray();
// ConvertAll - omvandla alla element till ny typ
List<string> upperNames = names.ConvertAll(name => name.ToUpper());
// Result: {"ANNA", "BERT", "CILLA"}
List<int> nameLengths = names.ConvertAll(name => name.Length);
// Result: {4, 4, 6}
// GetRange - hämta del av listan (kopierar)
List<string> subset = names.GetRange(1, 2); // {"Bert", "Cilla"}
Användning med LINQ (System.Linq)
using System.Linq;
List<int> numbers = new List<int>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// Where - filtrera element
var evens = numbers.Where(x => x % 2 == 0).ToList(); // {2, 4, 6, 8, 10}
// Select - transformera element
var squares = numbers.Select(x => x * x).ToList(); // {1, 4, 9, 16, 25, 36, 49, 64, 81, 100}
// OrderBy - sortera utan att ändra original
var sorted = numbers.OrderBy(x => x).ToList(); // {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
// Aggregat funktioner
int sum = numbers.Sum(); // 55
double average = numbers.Average(); // 5.5
int max = numbers.Max(); // 10
int min = numbers.Min(); // 1
// First/Last
int first = numbers.First(); // 1
int last = numbers.Last(); // 10
int firstLarge = numbers.First(x => x > 5); // 6
ForEach och iteration
List<string> heroes = new List<string>{"Iron Man", "Thor", "Hulk"};
// ForEach - utför action på alla element
heroes.ForEach(hero => Console.WriteLine($"⚡ {hero}"));
// Vanlig foreach loop
foreach (string hero in heroes)
{
Console.WriteLine($"🦸 {hero}");
}
// For loop med index
for (int i = 0; i < heroes.Count; i++)
{
Console.WriteLine($"{i + 1}. {heroes[i]}");
}
**Performance tips för List**
// ✅ Sätt initial kapacitet om du vet storleken
List<int> efficientList = new List<int>(1000); // Förhindrar resize
// ✅ TrimExcess för att minska minne efter många Remove
List<int> bigList = new List<int>(1000);
// ... lägg till och ta bort många element
bigList.TrimExcess(); // Minska intern array till exact storlek
// ❌ Undvik många Insert(0, value) - O(n) operation
// ✅ Använd Add() och sedan Reverse() om möjligt
// ✅ Använd Capacity property för att se intern storlek
Console.WriteLine($"Count: {bigList.Count}, Capacity: {bigList.Capacity}");
I det här exemplet skapar vi en generisk lista av typen string och fyller den med Star Wars-hjältarnas namn. Vi använder sedan olika metoder som Add, Count, Remove och indexeringsoperatorn [] för att hantera och manipulera listan. Slutligen loopar vi igenom listan med hjälp av en foreach-loop och skriver ut namnen på hjältarna.
Genom att använda den generiska List-klassen kan du enkelt hantera och manipulera listor med objekt av vilken typ som helst, inklusive Star Wars-hjältar!
Fortsätt gärna att utforska andra datastrukturer och hur de kan användas inom programmering. Varje datastruktur har sina egna unika egenskaper och användningsområden, och kunskap om dem kan vara värdefull för att skapa effektiv och strukturerad kod.
Vad är en arraylista?
En arraylista är en typ av lista som tillåter hantering av objekt av vilken typ som helst. Arraylistan är en dynamisk samling av objekt, vilket innebär att den kan växa och minska i storlek. Detta är en stor fördel jämfört med en array, som har en fast storlek.
Arraylistan är en klass som ärver från CollectionBase, vilket innebär att den har samma egenskaper som en array.
För att skapa en arraylista i C-Sharp med Star Wars-hjältar kan du använda följande kodexempel:
ArrayList starWarsHeroes = new ArrayList();
// Lägg till hjältar i listan
starWarsHeroes.Add("Luke Skywalker");
starWarsHeroes.Add("Princess Leia");
starWarsHeroes.Add("Han Solo");
starWarsHeroes.Add("Obi-Wan Kenobi");
// Hämta antalet hjältar i listan
int count = starWarsHeroes.Count;
Console.WriteLine("Antal hjältar: " + count);
// Hämta en hjälte från listan baserat på index
string hero = (string)starWarsHeroes[0];
Console.WriteLine("Första hjälten: " + hero);
// Uppdatera en hjälte i listan
starWarsHeroes[3] = "Yoda";
// Ta bort en hjälte från listan
starWarsHeroes.Remove("Han Solo");
// Loopa igenom och skriv ut alla hjältar i listan
foreach (string name in starWarsHeroes)
{
Console.WriteLine(name);
}
Output:
Antal hjältar: 4
Första hjälten: Luke Skywalker
Luke Skywalker
Princess Leia
Yoda
I det här exemplet skapar vi en arraylista och fyller den med Star Wars-hjältarnas namn. Vi använder sedan olika metoder som Add, Count, Remove och indexeringsoperatorn [] för att hantera och manipulera listan. Slutligen loopar vi igenom listan med hjälp av en foreach-loop och skriver ut namnen på hjältarna.
Genom att använda en arraylista kan du enkelt hantera och manipulera listor med objekt av vilken typ som helst, inklusive Star Wars-hjältar!
ArrayListor kan ta emot olika typer samtidigt, detta gör att man måste omvandla tillbaka till den typ man vill använda. Det kan göra ArrayListor lite krångliga att använda.
ArrayList luke = new ArrayList();
luke.Add("Luke Skywalker");
luke.Add(23); // Ålder
luke.Add(true); // Är han en jedi?
string name = (string)luke[0];
int age = (int)luke[1];
bool isJedi = (bool)luke[2];
Fortsätt gärna att utforska andra datastrukturer och hur de kan användas inom programmering. Varje datastruktur har sina egna unika egenskaper och användningsområden, och kunskap om dem kan vara värdefull för att skapa effektiv och strukturerad kod.
TL;DR
Med listor kan vi samla ihop flera objekt av samma typ. Vi kan sedan använda olika metoder för att hantera listan. Vi kan t.ex. lägga till och ta bort objekt, eller hämta ett objekt baserat på dess index. Vi kan även loopa igenom listan och göra något med varje objekt.
Obligatorisk dad-joke
Varför gillar programmerare att arbeta med listor?
För att de är listiga och hjälper till att hålla ordning på saker!