C#-gezacktes Array

C#-Jagged-Array

In diesem Tutorial lernen wir das gezackte C#-Array kennen. Wir werden anhand von Beispielen lernen, das gezackte Array zu deklarieren, zu initialisieren und darauf zuzugreifen.

In C# besteht ein gezacktes Array aus mehreren Arrays als Element. Im Gegensatz zu mehrdimensionalen Arrays kann jedoch jedes Array innerhalb eines gezackten Arrays unterschiedliche Größen haben.

Bevor Sie etwas über gezackte Arrays lernen, sollten Sie sich mit

vertraut machen

• C#-Arrays
• Mehrdimensionale C#-Arrays

---

C# Jagged Array-Deklaration

Hier ist eine Syntax, um ein gezacktes Array in C# zu deklarieren.

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

Sehen wir uns ein Beispiel an,

// declare jagged array
int[ ][ ] jaggedArray = new int[2][ ];

Hier,

• int - Datentyp des Arrays
• [][] - stellt ein gezacktes Array dar
• jaggedArray - Name des gezackten Arrays
• [2][] - repräsentiert die Anzahl der Elemente (Arrays) innerhalb des gezackten Arrays

Da wir wissen, dass jedes Element eines gezackten Arrays auch ein Array ist, können wir die Größe des einzelnen Arrays festlegen. Zum Beispiel

// set size of the first array as 3
jaggedArray[0] = new int[3];

// set size of second array as 2
jaggedArray[1] = new int[2];

---

Jagged Array wird initialisiert

Es gibt verschiedene Möglichkeiten, ein gezacktes Array zu initialisieren. Zum Beispiel

1. Verwenden der Indexnummer

Sobald wir ein gezacktes Array deklariert haben, können wir die Indexnummer verwenden, um es zu initialisieren. Zum Beispiel

// initialize the first array
jaggedArray[0][0] = 1;
jaggedArray[0][1] = 3;
jaggedArray[0][2] = 5;

// initialize the second array
jaggedArray[1][0] = 2;
jaggedArray[1][1] = 4;

Hier,

• Index in der ersten eckigen Klammer repräsentiert den Index des gezackten Array-Elements
• Index in der zweiten eckigen Klammer repräsentiert den Index des Elements innerhalb jedes Elements des gezackten Arrays

2. Initialisieren, ohne die Größe der Array-Elemente festzulegen

// declaring string jagged array
int[ ][ ] jaggedArray = new int[2] [ ];

// initialize each array
jaggedArray[0] = new int[] {1, 3, 5};
jaggedArray[1] = new int[] {2, 4};

3. Initialisieren, während Jagged Array deklariert wird

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

---

Zugriff auf Elemente eines gezackten Arrays

Über die Indexnummer können wir auf die Elemente des gezackten Arrays zugreifen. Zum Beispiel

// access first element of second array
jaggedArray[1][0];

// access second element of the second array
jaggedArray[1][1];

// access second element of the first array
jaggedArray[0][1];

---

Beispiel:C# Jagged Array

using System;

namespace JaggedArray {
  class Program {
    static void Main(string[] args) {

     // create a jagged array
     int[ ][ ] jaggedArray = {
         new int[] {1, 3, 5},
         new int[] {2, 4},
      };

     // print elements of jagged array
     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

Hier, in einem gezackten Array,

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

---

Iteration durch ein gezacktes Array

In C# können wir Schleifen verwenden, um jedes Element des gezackten Arrays zu durchlaufen. Zum Beispiel

using System;

namespace JaggedArray {
  class Program {
    static void Main(string[] args) {

      // declare a jagged array
      int[][] jaggedArray = new int[2][];

      // set size of Jagged Array Elements
      jaggedArray[0] = new int[3];
      jaggedArray[1] = new int[2];

      // initialize the first array
      jaggedArray[0][0] = 1;
      jaggedArray[0][1] = 3;
      jaggedArray[0][2] = 5;

      // initialize the second array
      jaggedArray[1][0] = 2;
      jaggedArray[1][1] = 2;
      	 
      // outer for loop
      for (int i = 0; i < jaggedArray.Length; i++) {

        Console.Write("Element "+ i +": ");
        // inner for loop
        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

Im obigen Beispiel haben wir eine verschachtelte for-Schleife verwendet, um das gezackte Array zu durchlaufen. Hier,

1. Äußere for-Schleife

• um auf die Elemente (Arrays) des gezackten Arrays zuzugreifen
• jaggedArray.Length - Gibt die Größe des gezackten Arrays an

2. Innere for-Schleife

• um auf die Elemente des einzelnen Arrays innerhalb des gezackten Arrays zuzugreifen.
• jaggedArray[i].Length - Gibt die Größe der Elemente des ith an Array innerhalb des gezackten Arrays

---

Gezacktes Array mit mehrdimensionalem Array

In C# können wir auch mehrdimensionale Arrays als Jagged Array Elements verwenden. Zum Beispiel

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

Hier ist jedes Element des gezackten 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

Sehen wir uns ein Beispiel an,

using System;

namespace JaggedArray  {
  class Program {
    static void Main(string[] args)  {
  	 
      // declare and initialize jagged array with 2D array
      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 im obigen Beispiel den Code,

jaggedArray[0][0, 1]

Hier,

• [0] - repräsentiert das erste Element (2D-Array) des gezackten Arrays
• [0, 1] - repräsentiert das zweite Element des ersten Arrays innerhalb des 2D-Arrays