C# Jagged Array

In deze tutorial leren we over de C# jagged array. We leren declareren, initialiseren en benaderen van de jagged array met behulp van voorbeelden.

In C# bestaat een jagged array uit meerdere arrays als elementen. In tegenstelling tot multidimensionale arrays, kan elke array binnen een jagged array een andere grootte hebben.

Voordat u over jagged arrays leert, zorg dat u kennis heeft van:

• C# Arrays
• C# Multidimensionale Arrays

C# Jagged Array Declaratie

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

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

Laten we een voorbeeld zien:

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

Hier:

• int - datatype van de array
• [][] - vertegenwoordigt jagged array
• jaggedArray - naam van de jagged array
• [2][] - vertegenwoordigt het aantal elementen (arrays) binnen de jagged array

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

// grootte van eerste array op 3 zetten
jaggedArray[0] = new int[3];
// grootte van tweede array op 2 zetten
jaggedArray[1] = new int[2];

Jagged Array Initialiseren

Er zijn verschillende manieren om een jagged array te initialiseren. Bijvoorbeeld:

1. Met Indexnummer

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

// eerste array initialiseren
jaggedArray[0][0] = 1;
jaggedArray[0][1] = 3;
jaggedArray[0][2] = 5;
// tweede array initialiseren
jaggedArray[1][0] = 2;
jaggedArray[1][1] = 4;

Hier:

• index bij de eerste vierkante haak vertegenwoordigt de index van het jagged array element
• index bij de tweede vierkante haak vertegenwoordigt de index van het element binnen elk element van de jagged array

2. Initialiseren Zonder Grootte van Array Elementen In te Stellen

// string jagged array declareren
int[ ][ ] jaggedArray = new int[2] [ ];
// elke array initialiseren
jaggedArray[0] = new int[] {1, 3, 5};
jaggedArray[1] = new int[] {2, 4};

3. Initialiseren Tijdens Declaratie van Jagged Array

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

Elementen van een Jagged Array Benaderen

We kunnen de elementen van de jagged array benaderen met het indexnummer. Bijvoorbeeld:

// eerste element van tweede array
jaggedArray[1][0];
// tweede element van tweede array
jaggedArray[1][1];
// tweede element van eerste array
jaggedArray[0][1];

Voorbeeld: C# Jagged Array

using System;
namespace JaggedArray {
    class Program {
        static void Main(string[] args) {
            // jagged array aanmaken
            int[ ][ ] jaggedArray = { new int[] {1, 3, 5}, new int[] {2, 4}, };
            // elementen van jagged array printen
            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();
        }
    }
}

Output

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

Hier, binnen een jagged 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

Door een Jagged Array Itereren

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

using System;
namespace JaggedArray {
    class Program {
        static void Main(string[] args) {
            // jagged array declareren
            int[][] jaggedArray = new int[2][];
            // grootte van Jagged Array Elementen instellen
            jaggedArray[0] = new int[3];
            jaggedArray[1] = new int[2];
            // eerste array initialiseren
            jaggedArray[0][0] = 1;
            jaggedArray[0][1] = 3;
            jaggedArray[0][2] = 5;
            // tweede array initialiseren
            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();
        }
    }
}

Output

Element 0: 1 3 5
Element 1: 2 2

In het bovenstaande voorbeeld hebben we een geneste for loop gebruikt om door de jagged array te itereren. Hier:

1. Outer for loop

• om de elementen (arrays) van de jagged array te benaderen
• jaggedArray.Length - geeft de grootte van de jagged array

2. Inner for loop

• om de elementen van de individuele array binnen de jagged array te benaderen.
• jaggedArray[i].Length - geeft de grootte van elementen van de i-de array binnen de jagged array

Jagged Array met Multidimensionale Array

In C# kunnen we ook multidimensionale arrays als Jagged Array Elementen gebruiken. 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 jagged 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 zien:

using System;
namespace JaggedArray {
    class Program {
        static void Main(string[] args) {
            // declareren en initialiseren jagged array met 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();
        }
    }
}

Output

8
10
100

In het bovenstaande voorbeeld, let op de code:

jaggedArray[0][0, 1]

Hier:

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