C# Jagged Array

In deze zelfstudie leren we over de C# jagged array. We zullen leren om de gekartelde array te declareren, te initialiseren en te benaderen met behulp van voorbeelden.

In C# bestaat een gekartelde array uit meerdere arrays als element. In tegenstelling tot multidimensionale arrays kan elke array in een gekartelde array echter verschillende grootten hebben.

Voordat u meer te weten komt over gekartelde arrays, moet u eerst meer weten over

C#-matrices
C# multidimensionale arrays

C# Jagged Array-verklaring

Hier is een syntaxis om een gekartelde array in C# te declareren.

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

Laten we een voorbeeld bekijken,

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

Hier,

int - gegevenstype van de array
[][] - staat voor gekartelde array
jaggedArray - naam van de gekartelde array
[2][] - vertegenwoordigt het aantal elementen (arrays) binnen de gekartelde array

Omdat we weten dat elk element van een gekartelde array ook een array is, kunnen we de grootte van de individuele array instellen. Bijvoorbeeld,

// 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 initialiseren

Er zijn verschillende manieren om een gekartelde array te initialiseren. Bijvoorbeeld,

1. Het indexnummer gebruiken

Zodra we een gekartelde array declareren, kunnen we het indexnummer gebruiken om het te initialiseren. Bijvoorbeeld,

// 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 bij het eerste vierkante haakje staat voor de index van het gekartelde array-element
index bij de tweede vierkante haak staat voor de index van het element binnen elk element van de gekartelde array

2. Initialiseren zonder de grootte van array-elementen in te stellen

// 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. Initialiseren tijdens het declareren van Jagged Array

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

Toegang tot elementen van een gekartelde array

We hebben toegang tot de elementen van de gekartelde array met behulp van het indexnummer. Bijvoorbeeld,

// 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];

Voorbeeld: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();
    }    
  }
}

Uitvoer

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

Hier, in een gekartelde array,

jaggedArray[1][0] - eerste element van de tweede array
jaggedArray[1][1] - tweede element van de tweede array
jaggedArray[0][2] - derde element van de eerste array

Itereren door een gekartelde array

In C# kunnen we lussen gebruiken om door elk element van de gekartelde array te itereren. Bijvoorbeeld,

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();
    } 
  }
}

Uitvoer

Element 0: 1 3 5
Element 1: 2 2

In het bovenstaande voorbeeld hebben we een geneste for-lus gebruikt om door de gekartelde array te itereren. Hier,

1. Buitenste voor lus

om toegang te krijgen tot de elementen (arrays) van de gekartelde array
jaggedArray.Length - geeft de grootte van de gekartelde array

2. Binnenste voor lus

om toegang te krijgen tot de elementen van de individuele array binnen de gekartelde array.
jaggedArray[i].Length - geeft de grootte van elementen van de ith array binnen de gekartelde array

Jagged array met multidimensionale array

In C# kunnen we ook multidimensionale arrays gebruiken als Jagged Array Elements. Bijvoorbeeld,

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

Hier is elk element van de gekartelde array een multidimensionale array:

new int[,] { {1, 8}, {6, 7} } - 2D-array met 2 elementen
new int[ , ] { {0, 3}, {5, 6}, {9, 10} } - 2D-array met 3 elementen

Laten we een voorbeeld bekijken,

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();
    }    
  }
}

Uitvoer

8
10
100

Let in het bovenstaande voorbeeld op de code,

jaggedArray[0][0, 1]

Hier,

[0] - vertegenwoordigt het eerste element (2D-array) van de gekartelde array
[0, 1] - vertegenwoordigt het tweede element van de eerste array binnen de 2D-array

C# Multidimensionale array C# foreach-lus

C Taal