Larik

Anda dapat menyimpan beberapa variabel dengan jenis yang sama dalam struktur data array. Anda menyatakan array dengan menentukan jenis elemennya. Jika Anda ingin array menyimpan elemen dari jenis apa pun, Anda dapat menentukan object sebagai jenisnya. Dalam sistem jenis terpadu C#, semua jenis, yang telah ditentukan dan ditentukan pengguna, jenis referensi dan jenis nilai, mewarisi secara langsung atau tidak langsung dari Object.

type[] arrayName;

Array adalah tipe referensi, sehingga array bisa menjadi tipe referensi nullable. Jenis elemen mungkin merupakan jenis referensi, sehingga array dapat dinyatakan untuk menyimpan jenis referensi yang dapat bernilai null. Contoh deklarasi berikut menunjukkan sintaks yang berbeda yang digunakan untuk mendeklarasikan nullability dari array atau elemen-elemen:

type?[] arrayName; // non nullable array of nullable element types.
type[]? arrayName; // nullable array of non-nullable element types.
type?[]? arrayName; // nullable array of nullable element types.

Elemen yang tidak diinisialisasi dalam array diatur ke nilai default untuk jenis tersebut:

int[] numbers = new int[10]; // All values are 0
string[] messages = new string[10]; // All values are null.

Penting

Dalam contoh sebelumnya, meskipun jenisnya string[], array string yang tidak dapat diubah ke null, nilai default untuk setiap elemen adalah null. Cara terbaik untuk menginisialisasi array ke nilai non-null adalah dengan menggunakan ekspresi koleksi .

Array memiliki properti berikut:

• Array dapat berupa dimensi tunggal, multidimensi, atau bergerigi.
• Jumlah dimensi diatur saat variabel array dideklarasikan. Panjang setiap dimensi ditetapkan saat instans array dibuat. Nilai-nilai ini tidak dapat diubah selama masa pakai instans.
• Array bergerigi adalah array dari array, dan setiap array anggota memiliki nilai default null.
• Array diindekskan ke nol: array dengan elemen n diindeks dari 0 ke n-1.
• Elemen array dapat berupa elemen dari jenis apa pun, termasuk jenis array.
• Jenis array adalah jenis referensi yang berasal dari tipe dasar abstrak Array. Semua array mengimplementasikan IList dan IEnumerable. Anda dapat menggunakan pernyataan foreach untuk melakukan perulangan dalam satu array. Array dimensi-tunggal juga mengimplementasikan IList<T> dan IEnumerable<T>.

Elemen array dapat diinisialisasi ke nilai yang diketahui saat array dibuat. Dimulai dengan C# 12, semua jenis koleksi dapat diinisialisasi menggunakan ekspresi koleksi. Elemen yang tidak diinisialisasi diatur ke nilai default. Nilai defaultnya adalah pola 0-bit. Semua jenis referensi (termasuk jenis yang tidak dapat diubah ke null), memiliki nilai null. Semua jenis nilai memiliki pola 0-bit. Itu berarti Nullable<T>.HasValue properti adalah false dan Nullable<T>.Value properti tidak ditentukan. Dalam implementasi .NET, Value properti melemparkan pengecualian.

Contoh berikut membuat array satu dimensi, multidimensi, dan jagged:

// Declare a single-dimensional array of 5 integers.
int[] array1 = new int[5];

// Declare and set array element values.
int[] array2 = [1, 2, 3, 4, 5, 6];

// Declare a two dimensional array.
int[,] multiDimensionalArray1 = new int[2, 3];

// Declare and set array element values.
int[,] multiDimensionalArray2 = { { 1, 2, 3 }, { 4, 5, 6 } };

// Declare a jagged array.
int[][] jaggedArray = new int[6][];

// Set the values of the first array in the jagged array structure.
jaggedArray[0] = [1, 2, 3, 4];

Penting

Banyak contoh dalam artikel ini menggunakan ekspresi kumpulan (yang menggunakan tanda kurung siku) untuk menginisialisasi array. Ekspresi koleksi pertama kali diperkenalkan dalam C# 12, yang dirilis dengan .NET 8. Jika Anda belum dapat meningkatkan ke C# 12, gunakan { dan } untuk menginisialisasi array sebagai gantinya.

// Collection expressions:
int[] array = [1, 2, 3, 4, 5, 6];
// Alternative syntax:
int[] array2 = {1, 2, 3, 4, 5, 6};

Array Satu Dimensi

Array dimensi tunggal adalah urutan elemen sejenis. Anda mengakses elemen melalui indeksnya. Indeks adalah posisi ordinalnya secara berurutan. Elemen pertama dalam array berada di indeks 0. Anda membuat array dimensi tunggal di C# menggunakan operator baru yang menentukan jenis elemen array dan jumlah elemen. Contoh berikut mendeklarasikan dan menginisialisasi array dimensi tunggal:

int[] array = new int[5];
string[] weekDays = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];

Console.WriteLine(weekDays[0]);
Console.WriteLine(weekDays[1]);
Console.WriteLine(weekDays[2]);
Console.WriteLine(weekDays[3]);
Console.WriteLine(weekDays[4]);
Console.WriteLine(weekDays[5]);
Console.WriteLine(weekDays[6]);

/*Output:
Sun
Mon
Tue
Wed
Thu
Fri
Sat
*/

Deklarasi pertama menyatakan array yang tidak diinisialisasi dari lima bilangan bulat, dari array[0] ke array[4]. Elemen array diinisialisasi ke nilai default jenis elemen, 0 untuk bilangan bulat. Deklarasi kedua mendeklarasikan array string dan menginisialisasi ketujuh nilai array tersebut. Serangkaian pernyataan Console.WriteLine mencetak seluruh elemen dari larik weekDay. Untuk array dimensi tunggal, foreach pernyataan memproses elemen dalam meningkatkan urutan indeks, dimulai dengan indeks 0 dan berakhir dengan indeks Length - 1.

Mengoper array satu dimensi sebagai argumen

Anda dapat meneruskan array satu dimensi yang sudah diinisialisasi ke sebuah metode. Dalam contoh berikut, sebuah array string diinisialisasi dan diteruskan sebagai argumen ke metode DisplayArray yang berfungsi untuk string. Metode ini menampilkan elemen array. Selanjutnya, metode ChangeArray akan membalikkan elemen array, lalu metode ChangeArrayElements mengubah tiga elemen pertama array tersebut. Setelah setiap metode kembali, metode DisplayArray menunjukkan bahwa array yang diteruskan dengan nilai tidak akan mencegah perubahan pada elemen-elemennya.

class ArrayExample
{
    static void DisplayArray(string[] arr) => Console.WriteLine(string.Join(" ", arr));

    // Change the array by reversing its elements.
    static void ChangeArray(string[] arr) => Array.Reverse(arr);

    static void ChangeArrayElements(string[] arr)
    {
        // Change the value of the first three array elements.
        arr[0] = "Mon";
        arr[1] = "Wed";
        arr[2] = "Fri";
    }

    static void Main()
    {
        // Declare and initialize an array.
        string[] weekDays = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
        // Display the array elements.
        DisplayArray(weekDays);
        Console.WriteLine();

        // Reverse the array.
        ChangeArray(weekDays);
        // Display the array again to verify that it stays reversed.
        Console.WriteLine("Array weekDays after the call to ChangeArray:");
        DisplayArray(weekDays);
        Console.WriteLine();

        // Assign new values to individual array elements.
        ChangeArrayElements(weekDays);
        // Display the array again to verify that it has changed.
        Console.WriteLine("Array weekDays after the call to ChangeArrayElements:");
        DisplayArray(weekDays);
    }
}
// The example displays the following output:
//         Sun Mon Tue Wed Thu Fri Sat
//
//        Array weekDays after the call to ChangeArray:
//        Sat Fri Thu Wed Tue Mon Sun
//
//        Array weekDays after the call to ChangeArrayElements:
//        Mon Wed Fri Wed Tue Mon Sun

Array multidimensi

Larik dapat memiliki lebih dari satu dimensi. Misalnya, deklarasi berikut membuat empat array. Dua array memiliki dua dimensi. Dua array memiliki tiga dimensi. Dua deklarasi pertama mendeklarasikan panjang setiap dimensi, tetapi jangan menginisialisasi nilai array. Dua deklarasi kedua menggunakan penginisialisasi untuk mengatur nilai setiap elemen dalam array multidimensi.

int[,] array2DDeclaration = new int[4, 2];

int[,,] array3DDeclaration = new int[4, 2, 3];

// Two-dimensional array.
int[,] array2DInitialization =  { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
// Three-dimensional array.
int[,,] array3D = new int[,,] { { { 1, 2, 3 }, { 4,   5,  6 } },
                                { { 7, 8, 9 }, { 10, 11, 12 } } };

// Accessing array elements.
System.Console.WriteLine(array2DInitialization[0, 0]);
System.Console.WriteLine(array2DInitialization[0, 1]);
System.Console.WriteLine(array2DInitialization[1, 0]);
System.Console.WriteLine(array2DInitialization[1, 1]);

System.Console.WriteLine(array2DInitialization[3, 0]);
System.Console.WriteLine(array2DInitialization[3, 1]);
// Output:
// 1
// 2
// 3
// 4
// 7
// 8

System.Console.WriteLine(array3D[1, 0, 1]);
System.Console.WriteLine(array3D[1, 1, 2]);
// Output:
// 8
// 12

// Getting the total count of elements or the length of a given dimension.
var allLength = array3D.Length;
var total = 1;
for (int i = 0; i < array3D.Rank; i++)
{
    total *= array3D.GetLength(i);
}
System.Console.WriteLine($"{allLength} equals {total}");
// Output:
// 12 equals 12

Untuk array multidimensi, elemen dilalui sedemikian rupa sehingga indeks dimensi paling kanan ditambah terlebih dahulu, lalu dimensi berikutnya di kiri, dan seterusnya, hingga indeks paling kiri. Contoh berikut menghitung array 2D dan 3D:

int[,] numbers2D = { { 9, 99 }, { 3, 33 }, { 5, 55 } };

foreach (int i in numbers2D)
{
    System.Console.Write($"{i} ");
}
// Output: 9 99 3 33 5 55

int[,,] array3D = new int[,,] { { { 1, 2, 3 }, { 4,   5,  6 } },
                        { { 7, 8, 9 }, { 10, 11, 12 } } };
foreach (int i in array3D)
{
    System.Console.Write($"{i} ");
}
// Output: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12

Dalam array 2D, Anda dapat menganggap indeks kiri sebagai baris dan indeks kanan sebagai kolom.

Namun, dengan array multidimensi, menggunakan perulangan for bersarang memberi Anda lebih banyak kontrol atas urutan untuk memproses elemen array.

int[,,] array3D = new int[,,] { { { 1, 2, 3 }, { 4,   5,  6 } },
                        { { 7, 8, 9 }, { 10, 11, 12 } } };

for (int i = 0; i < array3D.GetLength(0); i++)
{
    for (int j = 0; j < array3D.GetLength(1); j++)
    {
        for (int k = 0; k < array3D.GetLength(2); k++)
        {
            System.Console.Write($"{array3D[i, j, k]} ");
        }
        System.Console.WriteLine();
    }
    System.Console.WriteLine();
}
// Output (including blank lines):
// 1 2 3
// 4 5 6
//
// 7 8 9
// 10 11 12
//

Masukkan array multidimensional sebagai argumen

Anda meneruskan array multidimensi yang diinisialisasi ke metode dengan cara yang sama seperti Anda meneruskan array satu dimensi. Kode berikut menunjukkan deklarasi parsial metode cetak yang menerima array dua dimensi sebagai argumennya. Anda dapat menginisialisasi dan meneruskan array baru dengan satu langkah, seperti yang diperlihatkan dalam contoh berikut. Dalam contoh berikut, array integer dua dimensi diinisialisasi dan diteruskan ke metode Print2DArray. Metode ini menampilkan elemen array.

static void Print2DArray(int[,] arr)
{
    // Display the array elements.
    for (int i = 0; i < arr.GetLength(0); i++)
    {
        for (int j = 0; j < arr.GetLength(1); j++)
        {
            System.Console.WriteLine($"Element({i},{j})={arr[i,j]}");
        }
    }
}
static void ExampleUsage()
{
    // Pass the array as an argument.
    Print2DArray(new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } });
}
/* Output:
    Element(0,0)=1
    Element(0,1)=2
    Element(1,0)=3
    Element(1,1)=4
    Element(2,0)=5
    Element(2,1)=6
    Element(3,0)=7
    Element(3,1)=8
*/

Array Tidak Beraturan

Array bergerigi adalah array yang elemen-elemennya adalah array, mungkin berbeda ukuran. Array bergerigi kadang-kadang disebut "array dari array." Elemennya adalah tipe referensi dan diinisialisasi ke null. Contoh berikut menunjukkan cara mendeklarasikan, menginisialisasi, dan mengakses array bersudut. Contoh pertama, jaggedArray, dinyatakan dalam satu pernyataan. Setiap array yang terkandung dibuat dalam pernyataan berikutnya. Contoh kedua, jaggedArray2 dinyatakan dan diinisialisasi dalam satu pernyataan. Dimungkinkan untuk menggabungkan array bergerigi dan multidimensi. Contoh terakhir, jaggedArray3, adalah deklarasi dan inisialisasi dari array bergerigi satu dimensi yang berisi tiga elemen array dua dimensi dengan ukuran berbeda-beda.

int[][] jaggedArray = new int[3][];

jaggedArray[0] = [1, 3, 5, 7, 9];
jaggedArray[1] = [0, 2, 4, 6];
jaggedArray[2] = [11, 22];

int[][] jaggedArray2 =
[
    [1, 3, 5, 7, 9],
    [0, 2, 4, 6],
    [11, 22]
];

// Assign 77 to the second element ([1]) of the first array ([0]):
jaggedArray2[0][1] = 77;

// Assign 88 to the second element ([1]) of the third array ([2]):
jaggedArray2[2][1] = 88;

int[][,] jaggedArray3 =
[
    new int[,] { {1,3}, {5,7} },
    new int[,] { {0,2}, {4,6}, {8,10} },
    new int[,] { {11,22}, {99,88}, {0,9} }
];

Console.Write("{0}", jaggedArray3[0][1, 0]);
Console.WriteLine(jaggedArray3.Length);

Elemen array bergerigi harus diinisialisasi sebelum Anda dapat menggunakannya. Masing-masing elemen itu sendiri adalah array. Dimungkinkan juga untuk menggunakan penginisialisasi untuk mengisi elemen array dengan nilai. Saat Anda menggunakan penginisialisasi, Anda tidak memerlukan ukuran array.

Contoh ini membangun array yang elemennya adalah array itu sendiri. Masing-masing elemen array memiliki ukuran yang berbeda.

// Declare the array of two elements.
int[][] arr = new int[2][];

// Initialize the elements.
arr[0] = [1, 3, 5, 7, 9];
arr[1] = [2, 4, 6, 8];

// Display the array elements.
for (int i = 0; i < arr.Length; i++)
{
    System.Console.Write("Element({0}): ", i);

    for (int j = 0; j < arr[i].Length; j++)
    {
        System.Console.Write("{0}{1}", arr[i][j], j == (arr[i].Length - 1) ? "" : " ");
    }
    System.Console.WriteLine();
}
/* Output:
    Element(0): 1 3 5 7 9
    Element(1): 2 4 6 8
*/

Array yang bertipe implisit

Anda dapat membuat array yang diketik secara implisit di mana jenis instans array disimpulkan dari elemen yang ditentukan dalam penginisialisasi array. Aturan untuk variabel yang ditik secara implisit juga berlaku untuk array yang di ketik secara implisit. Untuk informasi selengkapnya, lihat Variabel Lokal Berjenis Implisit.

Contoh berikut menunjukkan cara membuat array yang ditik secara implisit:

int[] a = new[] { 1, 10, 100, 1000 }; // int[]

// Accessing array
Console.WriteLine("First element: " + a[0]);
Console.WriteLine("Second element: " + a[1]);
Console.WriteLine("Third element: " + a[2]);
Console.WriteLine("Fourth element: " + a[3]);
/* Outputs
First element: 1
Second element: 10
Third element: 100
Fourth element: 1000
*/

var b = new[] { "hello", null, "world" }; // string[]

// Accessing elements of an array using 'string.Join' method
Console.WriteLine(string.Join(" ", b));
/* Output
hello  world
*/

// single-dimension jagged array
int[][] c =
[
    [1,2,3,4],
    [5,6,7,8]
];
// Looping through the outer array
for (int k = 0; k < c.Length; k++)
{
    // Looping through each inner array
    for (int j = 0; j < c[k].Length; j++)
    {
        // Accessing each element and printing it to the console
        Console.WriteLine($"Element at c[{k}][{j}] is: {c[k][j]}");
    }
}
/* Outputs
Element at c[0][0] is: 1
Element at c[0][1] is: 2
Element at c[0][2] is: 3
Element at c[0][3] is: 4
Element at c[1][0] is: 5
Element at c[1][1] is: 6
Element at c[1][2] is: 7
Element at c[1][3] is: 8
*/

// jagged array of strings
string[][] d =
[
    ["Luca", "Mads", "Luke", "Dinesh"],
    ["Karen", "Suma", "Frances"]
];

// Looping through the outer array
int i = 0;
foreach (var subArray in d)
{
    // Looping through each inner array
    int j = 0;
    foreach (var element in subArray)
    {
        // Accessing each element and printing it to the console
        Console.WriteLine($"Element at d[{i}][{j}] is: {element}");
        j++;
    }
    i++;
}
/* Outputs
Element at d[0][0] is: Luca
Element at d[0][1] is: Mads
Element at d[0][2] is: Luke
Element at d[0][3] is: Dinesh
Element at d[1][0] is: Karen
Element at d[1][1] is: Suma
Element at d[1][2] is: Frances
*/

Dalam contoh sebelumnya, perhatikan bahwa dengan array yang diketik secara implisit, tidak ada tanda kurung siku yang digunakan di sisi kiri pernyataan inisialisasi. Selain itu, array bergerigi dapat diinisialisasi dengan menggunakan new [] sama seperti array berdimensi satu.

Saat Anda membuat tipe anonim yang berisi array, array tersebut harus berjenis implisit di penginisialisasi objek tipe tersebut. Dalam contoh berikut, contacts adalah array jenis anonim yang diketik secara implisit, yang masing-masing berisi array bernama PhoneNumbers. Kata var kunci tidak digunakan di dalam penginisialisasi objek.

var contacts = new[]
{
    new
    {
        Name = "Eugene Zabokritski",
        PhoneNumbers = new[] { "206-555-0108", "425-555-0001" }
    },
    new
    {
        Name = "Hanying Feng",
        PhoneNumbers = new[] { "650-555-0199" }
    }
};