Arrays

Arrays är som IKEA-skåp - massa lådor i rad där du kan stoppa saker! Fast till skillnad från IKEA… de här är lätta att komma åt! 😄

🎯 Efter denna artikel kommer du att:

Förstå array-konceptet - lådor i rad för att lagra data 📦
Skapa och använda arrays - deklarera, initiera, och accessa 🔨
Navigera med index - position 0, 1, 2… varför börjar vi på 0? 🤔
Hantera vanliga array-mistakes - och undvika ArrayOutOfBounds! 💥

📦 Array Basics - Syntax och Setup

Skapa arrays (3 sätt)

Sätt 1: Deklarera först, fyll sedan

// 1. Deklarera array med fast storlek
int[] numbers = new int[5];  // 5 tomma lådor för integers

// 2. Fyll lådorna
numbers[0] = 10;  // Första lådan (index 0)
numbers[1] = 20;  // Andra lådan (index 1)
numbers[4] = 50;  // Femte lådan (index 4)

Sätt 2: Deklarera och fyll direkt

// En rad = klart!
int[] scores = {95, 87, 92, 78, 88};

// Alternativ syntax (samma sak)
string[] names = new string[] {"Anna", "Bert", "Ceasar"};

Sätt 3: Smart initialization

// Automatisk storlek baserat på innehåll
var fruits = new[] {"Äpple", "Banan", "Citron"}; // 3 element
var primes = new[] {2, 3, 5, 7, 11, 13, 17};    // 7 element

🎯 Hands-On Övning: Student Grade System

using System;

class StudentGrades
{
    static void Main()
    {
        Console.WriteLine("📚 STUDENT GRADE MANAGEMENT SYSTEM");
        Console.WriteLine("==================================");

        // Skapa array för 5 studerandes betyg
        string[] students = {"Anna", "Bert", "Cilla", "David", "Emma"};
        int[] grades = {85, 92, 78, 96, 83};

        DisplayAllGrades(students, grades);
        FindTopStudent(students, grades);
        CalculateAverage(grades);

        // Uppdatera en students betyg
        UpdateGrade(students, grades, "Cilla", 88);

        DisplayAllGrades(students, grades);
    }

    static void DisplayAllGrades(string[] students, int[] grades)
    {
        Console.WriteLine("\n📊 Alla studentbetyg:");

        for (int i = 0; i < students.Length; i++)
        {
            Console.WriteLine($"  {students[i]}: {grades[i]} poäng");
        }
    }

    static void FindTopStudent(string[] students, int[] grades)
    {
        int topIndex = 0;
        int topGrade = grades[0];

        // Hitta högsta betyget
        for (int i = 1; i < grades.Length; i++)
        {
            if (grades[i] > topGrade)
            {
                topGrade = grades[i];
                topIndex = i;
            }
        }

        Console.WriteLine($"\n🏆 Bästa student: {students[topIndex]} med {topGrade} poäng!");
    }

    static void CalculateAverage(int[] grades)
    {
        int sum = 0;
        for (int i = 0; i < grades.Length; i++)
        {
            sum += grades[i];
        }

        double average = (double)sum / grades.Length;
        Console.WriteLine($"\n📈 Genomsnittligt betyg: {average:F1} poäng");
    }

    static void UpdateGrade(string[] students, int[] grades, string studentName, int newGrade)
    {
        // Hitta student och uppdatera betyg
        for (int i = 0; i < students.Length; i++)
        {
            if (students[i] == studentName)
            {
                int oldGrade = grades[i];
                grades[i] = newGrade;
                Console.WriteLine($"\n🔄 Uppdaterat {studentName}: {oldGrade} → {newGrade}");
                return;
            }
        }
        Console.WriteLine($"\n❌ Student {studentName} hittades inte!");
    }
}

🔧 Array Methods och Properties

Basic Properties

int[] data = {5, 2, 8, 1, 9};

// Essential properties
Console.WriteLine($"Length: {data.Length}");        // 5 (antal element)
Console.WriteLine($"Rank: {data.Rank}");            // 1 (antal dimensioner)
Console.WriteLine($"IsReadOnly: {data.IsReadOnly}"); // False
Console.WriteLine($"IsFixedSize: {data.IsFixedSize}"); // True

Static Array Methods - Sök och Hitta

int[] numbers = {10, 25, 30, 25, 45};

// IndexOf - hitta första förekomsten
int index = Array.IndexOf(numbers, 25);          // 1 (första 25:an)
int notFound = Array.IndexOf(numbers, 99);       // -1 (finns inte)

// LastIndexOf - hitta sista förekomsten
int lastIndex = Array.LastIndexOf(numbers, 25);  // 3 (sista 25:an)

// Exists - kontrollera om något finns
bool hasLarge = Array.Exists(numbers, x => x > 40);     // true (45 > 40)
bool hasNegative = Array.Exists(numbers, x => x < 0);   // false

// Find - hitta första som matchar
int found = Array.Find(numbers, x => x > 25);           // 30 (första > 25)
int notFoundValue = Array.Find(numbers, x => x > 100);  // 0 (default för int)

// FindIndex - hitta index för första som matchar
int foundIndex = Array.FindIndex(numbers, x => x > 25); // 2 (index för 30)

Static Array Methods - Ändra och Sortera

int[] data = {5, 2, 8, 1, 9};

// Sort - sortera array (ändrar original!)
Array.Sort(data);         // {1, 2, 5, 8, 9}

// Reverse - vänd ordning (ändrar original!)
Array.Reverse(data);      // {9, 8, 5, 2, 1}

// Clear - nollställ element (ändrar original!)
Array.Clear(data, 0, 2);  // {0, 0, 5, 2, 1} - nollställ första 2 element

// Copy - kopiera mellan arrays
int[] source = {1, 2, 3, 4, 5};
int[] destination = new int[5];
Array.Copy(source, destination, 3);  // Kopiera första 3: {1, 2, 3, 0, 0}

// Resize - ändra storlek (skapar ny array!)
Array.Resize(ref data, 10);  // Ny array med 10 platser

Advanced Array Methods

string[] names = {"Anna", "Bert", "Cilla", "David"};

// ConvertAll - omvandla alla element
string[] upperNames = Array.ConvertAll(names, name => name.ToUpper());
// Result: {"ANNA", "BERT", "CILLA", "DAVID"}

// FindAll - hitta alla som matchar (returnerar ny array)
int[] scores = {85, 92, 78, 96, 83, 91};
int[] highScores = Array.FindAll(scores, score => score >= 90);
// Result: {92, 96, 91}

// TrueForAll - kontrollera om alla matchar
bool allPassed = Array.TrueForAll(scores, score => score >= 70);  // true
bool allExcellent = Array.TrueForAll(scores, score => score >= 90); // false

// ForEach - utför action på alla element (VOID - returnerar inget)
Array.ForEach(names, name => Console.WriteLine($"Hej {name}!"));

Multidimensional Arrays

// 2D Array (rektangulärt)
int[,] matrix = new int[3, 4];  // 3 rader, 4 kolumner

// Fyll 2D array
for (int row = 0; row < matrix.GetLength(0); row++)  // GetLength(0) = antal rader
{
    for (int col = 0; col < matrix.GetLength(1); col++)  // GetLength(1) = antal kolumner
    {
        matrix[row, col] = row * 10 + col;
    }
}

// Jagged Array (oregelbunden)
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};

Copying Arrays

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

// ❌ Reference copy (farligt!)
int[] reference = original;  // Pekar på samma data!
reference[0] = 999;
Console.WriteLine(original[0]);  // 999 - original ändrades också!

// ✅ Value copy (säkert)
int[] copy = new int[original.Length];
Array.Copy(original, copy, original.Length);

// ✅ Modern LINQ way
int[] modernCopy = original.ToArray();

🆚 Arrays vs Lists - När använda vad?

🔒 Använd ARRAY när:

Du vet exakt storlek från början
Performance är kritisk (arrays är snabbare)
Du jobbar med low-level kod
Storleken ändras aldrig

// Perfect för arrays:
string[] weekDays = {"Måndag", "Tisdag", "Onsdag", "Torsdag", "Fredag", "Lördag", "Söndag"};
int[] monthDays = new int[31];  // Fast storlek

🔄 Använd LIST när:

Du behöver lägga till/ta bort element
Storleken är okänd från början
Du vill ha convenience methods
Du bygger dynamiska collections

// Perfect för List:
var shoppingCart = new List<string>();
shoppingCart.Add("Mjölk");
shoppingCart.Add("Bröd");
shoppingCart.Remove("Mjölk");  // Easy!

💡 Array Performance Tips

Memory och Speed

// ✅ Pre-size arrays för performance
int[] bigArray = new int[1000000];  // Allokera en gång

// ❌ Undvik konstant re-sizing
var list = new List<int>();
for (int i = 0; i < 1000000; i++)
{
    list.Add(i);  // Måste resize interna array många gånger
}

// ✅ Pre-size List också
var betterList = new List<int>(1000000);  // Hint om storlek

Cache-Friendly Patterns

int[,] matrix = new int[1000, 1000];

// ✅ Row-major order (snabbare)
for (int row = 0; row < 1000; row++)
{
    for (int col = 0; col < 1000; col++)
    {
        matrix[row, col] = row + col;
    }
}

// ❌ Column-major order (långsammare på grund av cache misses)
for (int col = 0; col < 1000; col++)
{
    for (int row = 0; row < 1000; row++)
    {
        matrix[row, col] = row + col;
    }
}

💡 Marcus Array Wisdom

*“Arrays är som Lego-bitar - enkla byggstenar som du kan skapa amazing saker med! Men kom ihåg - när du har byggt din Lego-slott kan du inte bara lägga till fler rum. Då behöver du List!"* 🧱

Real story: Första gången jag såg en array (år 1995) tänkte jag “varför börja på 0, det är ju konstigt!” Nu, 29 år senare, känns 1-baserad indexering konstigt. Hjärnan anpassar sig! 🧠

Pro tip: Arrays är foundations för ALLT i programming - strings, Lists, databases… Lär dig arrays ordentligt så förstår ni resten av datastrukturer mycket lättare! 💪

Ready för Lists och andra collections? Arrays är bara början! 🚀