C# Jagged Arrays meistern: Deklaration, Initialisierung und Zugriff

C# Jagged Arrays

In diesem Tutorial lernen wir über C# Jagged Arrays. Wir lernen, sie zu deklarieren, zu initialisieren und darauf zuzugreifen, mit Hilfe von Beispielen.

In C# besteht ein Jagged Array aus mehreren Arrays als Elemente. Im Gegensatz zu mehrdimensionalen Arrays kann jedes Array innerhalb eines Jagged Arrays eine unterschiedliche Größe haben.

Bevor Sie über Jagged Arrays lernen, stellen Sie sicher, dass Sie Folgendes kennen:

• C# Arrays
• C# Mehrdimensionale Arrays

---

C# Jagged Array Deklaration

Hier ist die Syntax zur Deklaration eines Jagged Arrays in C#:

dataType[ ][ ] nameOfArray = new dataType[rows][ ];

Beispiel:

// Jagged Array deklarieren
int[ ][ ] jaggedArray = new int[2][ ];

Hier:

• int - Datentyp des Arrays
• [][] - repräsentiert Jagged Array
• jaggedArray - Name des Jagged Arrays
• [2][] - Anzahl der Elemente (Arrays) im Jagged Array

Da jedes Element eines Jagged Arrays selbst ein Array ist, können wir die Größe der einzelnen Arrays festlegen. Zum Beispiel:

// Größe des ersten Arrays auf 3 setzen
jaggedArray[0] = new int[3];
// Größe des zweiten Arrays auf 2 setzen
jaggedArray[1] = new int[2];

---

Jagged Array initialisieren

Es gibt verschiedene Wege, ein Jagged Array zu initialisieren.

1. Mit Indexnummern

Nach der Deklaration können wir Indexnummern zur Initialisierung nutzen:

// erstes Array initialisieren
jaggedArray[0][0] = 1;
jaggedArray[0][1] = 3;
jaggedArray[0][2] = 5;
// zweites Array initialisieren
jaggedArray[1][0] = 2;
jaggedArray[1][1] = 4;

Hierbei:

• Index in der ersten eckigen Klammer = Index des Jagged Array Elements
• Index in der zweiten eckigen Klammer = Index des Elements innerhalb jedes Jagged Array Elements

2. Initialisieren ohne Größenfestlegung der Array-Elemente

// String Jagged Array deklarieren
int[ ][ ] jaggedArray = new int[2] [ ];
// jedes Array initialisieren
jaggedArray[0] = new int[] {1, 3, 5};
jaggedArray[1] = new int[] {2, 4};

3. Initialisieren bei der Deklaration

int[ ][ ] jaggedArray = { new int[ ] {10, 20, 30}, new int[ ] {11, 22}, new int[ ] {88, 99} };

---

Auf Elemente eines Jagged Arrays zugreifen

Wir können auf die Elemente des Jagged Arrays über Indexnummern zugreifen:

// erstes Element des zweiten Arrays
jaggedArray[1][0];
// zweites Element des zweiten Arrays
jaggedArray[1][1];
// zweites Element des ersten Arrays
jaggedArray[0][1];

---

Beispiel: C# Jagged Array

using System;
namespace JaggedArray {
    class Program {
        static void Main(string[] args) {
            // Jagged Array erstellen
            int[ ][ ] jaggedArray = { new int[] {1, 3, 5}, new int[] {2, 4}, };
            // Elemente ausgeben
            Console.WriteLine("jaggedArray[1][0]: " + jaggedArray[1][0]);
            Console.WriteLine("jaggedArray[1][1]: " + jaggedArray[1][1]);
            Console.WriteLine("jaggedArray[0][2]: " + jaggedArray[0][2]);
            Console.ReadLine();
        }
    }
}

Ausgabe

jaggedArray[1][0]: 2
jaggedArray[1][1]: 4
jaggedArray[0][2]: 5

Innerhalb eines Jagged Arrays:

• jaggedArray[1][0] - erstes Element des zweiten Arrays
• jaggedArray[1][1] - zweites Element des zweiten Arrays
• jaggedArray[0][2] - drittes Element des ersten Arrays

---

Durch ein Jagged Array iterieren

In C# können wir Schleifen nutzen, um durch jedes Element des Jagged Arrays zu iterieren:

using System;
namespace JaggedArray {
    class Program {
        static void Main(string[] args) {
            // Jagged Array deklarieren
            int[][] jaggedArray = new int[2][];
            // Größe der Jagged Array Elemente festlegen
            jaggedArray[0] = new int[3];
            jaggedArray[1] = new int[2];
            // erstes Array initialisieren
            jaggedArray[0][0] = 1;
            jaggedArray[0][1] = 3;
            jaggedArray[0][2] = 5;
            // zweites Array initialisieren
            jaggedArray[1][0] = 2;
            jaggedArray[1][1] = 2;
            // äußere for Schleife
            for (int i = 0; i < jaggedArray.Length; i++) {
                Console.Write("Element " + i + ": ");
                // innere for Schleife
                for (int j = 0; j < jaggedArray[i].Length; j++) {
                    Console.Write(jaggedArray[i][j] + " ");
                }
                Console.WriteLine();
            }
            Console.ReadLine();
        }
    }
}

Ausgabe

Element 0: 1 3 5
Element 1: 2 2

Hier nutzen wir eine verschachtelte for Schleife. Dabei:

1. Äußere for Schleife

• greift auf die Elemente (Arrays) des Jagged Arrays zu
• jaggedArray.Length gibt die Größe des Jagged Arrays an

2. Innere for Schleife

• greift auf die Elemente der einzelnen Arrays im Jagged Array zu
• jaggedArray[i].Length gibt die Größe der Elemente des i-ten Arrays an

---

Jagged Array mit mehrdimensionalem Array

In C# können wir auch mehrdimensionale Arrays als Jagged Array Elemente verwenden:

int[ ][ , ] jaggedArrayTwoD = new int[2][ , ] {
    new int[,] { {1, 8}, {6, 7} },
    new int[,] { {0, 3}, {5, 6}, {9, 10} }
};

Hier ist jedes Element des Jagged Arrays ein mehrdimensionales Array:

• new int[,] { {1, 8}, {6, 7} } - 2D Array mit 2 Elementen
• new int[ , ] { {0, 3}, {5, 6}, {9, 10} } - 2D Array mit 3 Elementen

Beispiel:

using System;
namespace JaggedArray {
    class Program {
        static void Main(string[] args) {
            // Jagged Array mit 2D Array deklarieren und initialisieren
            int[][,] jaggedArray = new int[3][ , ] {
                new int[ , ] { {1, 8}, {6, 7} },
                new int[ , ] { {0, 3}, {5, 6}, {9, 10} },
                new int[ , ] { {11, 23}, {100, 88}, {0, 10} }
            };
            Console.WriteLine(jaggedArray[0][0, 1]);
            Console.WriteLine(jaggedArray[1][2, 1]);
            Console.WriteLine(jaggedArray[2][1, 0]);
            Console.ReadLine();
        }
    }
}

Ausgabe

8 10 100

Beachten Sie den Code:

jaggedArray[0][0, 1]

Hier:

• [0] - erstes Element (2D Array) des Jagged Arrays
• [0, 1] - zweites Element des ersten Arrays innerhalb des 2D Arrays