Larik

  • Artikel

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 memiliki properti berikut:

  • Array dapat berupa dimensi tunggal, multidimensi, atau berjatuhan.
  • 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 berjatahan adalah array, dan setiap array anggota memiliki nilai nulldefault .
  • Array diindekskan ke nol: array dengan elemen n diindeks dari 0 ke n-1.
  • Elemen array dapat berupa array jenis apa pun, termasuk jenis array.
  • Jenis array adalah jenis referensi yang berasal dari jenis dasar yang 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 dimensi tunggal, multidimensi, dan berjajar:

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

Array Satu Dimensi

Array dimensi tunggal adalah urutan elemen seperti. 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 Console.WriteLine pernyataan mencetak semua elemen weekDay array. Untuk array dimensi tunggal, foreach pernyataan memproses elemen dalam meningkatkan urutan indeks, dimulai dengan indeks 0 dan berakhir dengan indeks Length - 1.

Meneruskan array dimensi tunggal sebagai argumen

Anda dapat meneruskan array dimensi tunggal yang diinisialisasi ke metode. Dalam contoh berikut, array string diinisialisasi dan diteruskan sebagai argumen ke metode DisplayArray 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 meneruskan array menurut nilai tidak akan mencegah perubahan pada elemen array.

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{i> 

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 sedih sehingga indeks dimensi paling kanan ditingkatkan terlebih dahulu, lalu dimensi kiri berikutnya, dan sebagainya, ke 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 multidampingan, menggunakan berlapis untuk perulangan 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
//

Meneruskan array multidireksional 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({0},{1})={2}", 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 Bergerigi

Array bergerigi adalah array yang terdiri dari array dengan ukuran yang berbeda. Array berjatahan kadang-kadang disebut "array array." Elemennya adalah jenis referensi dan diinisialisasi ke null. Contoh berikut menunjukkan cara mendeklarasikan, menginisialisasi, dan mengakses array jagged. 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 mencampur array bergerigi dan multidimensi. Contoh akhir, jaggedArray3, adalah deklarasi dan inisialisasi array berjatuhan dimensi tunggal yang berisi tiga elemen array dua dimensi dengan ukuran yang berbeda.

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 jagged 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 jagged diinisialisasi dengan menggunakan new [] sama seperti array dimensi tunggal.

Saat Anda membuat jenis anonim yang berisi array, array tersebut harus berjenis implisit di penginisialisasi objek jenis 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" }
    }
};