Tablice
Można przechowywać wiele zmiennych tego samego typu w strukturze danych tablicy. Zadeklaruj tablicę, określając typ jej elementów. Jeśli chcesz, aby tablica przechowywała elementy dowolnego typu, możesz określić object jej typ. W ujednoliconym systemie języka C#, wszystkie typy, wstępnie zdefiniowane i zdefiniowane przez użytkownika, typy referencyjne i typy wartości dziedziczą bezpośrednio lub pośrednio z Objectklasy .
type[] arrayName;
Tablica ma następujące właściwości:
- Tablica może być jednowymiarowa, wielowymiarowa lub postrzępiona.
- Liczba wymiarów jest ustawiana po zadeklarowaniu zmiennej tablicowej. Długość każdego wymiaru jest ustalana podczas tworzenia wystąpienia tablicy. Tych wartości nie można zmienić w okresie istnienia wystąpienia.
- Tablica postrzępiona jest tablicą tablic, a każda tablica składowa ma wartość
nulldomyślną . - Tablice są indeksowane zero: tablica z elementami
njest indeksowana z0don-1. - Elementy tablicy mogą być dowolnym typem, w tym typem tablicy.
- Typy tablic są typami referencyjnymi pochodzącymi z abstrakcyjnego typu Arraypodstawowego . Wszystkie tablice implementują i IList IEnumerable. Instrukcję foreach można użyć do iterowania tablicy. Tablice jednowymiarowe implementują IList<T> również i IEnumerable<T>.
Elementy tablicy można zainicjować do znanych wartości podczas tworzenia tablicy. Począwszy od języka C# 12, wszystkie typy kolekcji można zainicjować przy użyciu wyrażenia Kolekcja. Elementy, które nie są inicjowane, są ustawione na wartość domyślną. Wartość domyślna to wzorzec 0-bitowy. Wszystkie typy odwołań (w tym typy niezwiązane z wartościami null) mają wartości null. Wszystkie typy wartości mają wzorce 0-bitowe. Oznacza to, Nullable<T>.HasValue że właściwość jest false i Nullable<T>.Value właściwość jest niezdefiniowana. We implementacji Value platformy .NET właściwość zgłasza wyjątek.
Poniższy przykład tworzy tablice jednowymiarowe, wielowymiarowe i postrzępione:
// 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];
Ważne
Wiele przykładów w tym artykule używa wyrażeń kolekcji (które używają nawiasów kwadratowych) do inicjowania tablic. Wyrażenia kolekcji zostały po raz pierwszy wprowadzone w języku C# 12, które zostały dostarczone z platformą .NET 8. Jeśli nie możesz jeszcze uaktualnić do wersji C# 12, użyj polecenia { i } , aby zainicjować tablice.
// Collection expressions:
int[] array = [1, 2, 3, 4, 5, 6];
// Alternative syntax:
int[] array2 = {1, 2, 3, 4, 5, 6};
Tablice jednowymiarowe
Jednowymiarowa tablica jest sekwencją podobnych elementów. Dostęp do elementu można uzyskać za pośrednictwem jego indeksu. Indeks jest pozycją porządkową w sekwencji. Pierwszym elementem tablicy jest indeks 0. Tablica jednowymiarowa jest tworzona przy użyciu nowego operatora określającego typ elementu tablicy i liczbę elementów. Poniższy przykład deklaruje i inicjuje tablice jednowymiarowe:
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
*/
Pierwsza deklaracja deklaruje niezainicjowaną tablicę pięciu liczb całkowitych z array[0] do array[4]. Elementy tablicy są inicjowane do wartości domyślnej typu 0 elementu dla liczb całkowitych. Druga deklaracja deklaruje tablicę ciągów i inicjuje wszystkie siedem wartości tej tablicy. Seria instrukcji Console.WriteLine wyświetla wszystkie elementy weekDay tablicy. W przypadku tablic jednowymiarowych foreach instrukcja przetwarza elementy w kolejności rosnącej indeksu, począwszy od indeksu 0 i kończąc na indeksie Length - 1.
Przekazywanie tablic jednowymiarowych jako argumentów
Do metody można przekazać zainicjowaną jednowymiarową tablicę. W poniższym przykładzie tablica ciągów jest inicjowana i przekazywana jako argument do DisplayArray metody ciągów. Metoda wyświetla elementy tablicy. ChangeArray Następnie metoda odwraca elementy tablicy, a następnie ChangeArrayElements metoda modyfikuje pierwsze trzy elementy tablicy. Po dokonaniu każdej metody metoda pokazuje, DisplayArray że przekazywanie tablicy według wartości nie uniemożliwia zmian w elementach tablicy.
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
Tablice wielowymiarowe
Tablice mogą mieć więcej niż jeden wymiar. Na przykład następujące deklaracje tworzą cztery tablice: dwa mają dwa wymiary, dwa mają trzy wymiary. Pierwsze dwie deklaracje deklarują długość każdego wymiaru, ale nie inicjują wartości tablicy. Drugie dwie deklaracje używają inicjatora do ustawiania wartości każdego elementu w tablicy wielowymiarowej.
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
W przypadku tablic wielowymiarowych elementy są przechodzine w taki sposób, że indeksy wymiaru po prawej stronie są najpierw zwiększane, a następnie następny wymiar po lewej stronie, a tak dalej, do indeksu najbardziej po lewej stronie. Poniższy przykład wylicza zarówno tablicę 2D, jak i tablicę 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
W tablicy 2D można traktować indeks po lewej stronie jako wiersz i prawy indeks jako kolumnę.
Jednak w przypadku tablic wielowymiarowych użycie zagnieżdżonej pętli zapewnia większą kontrolę nad kolejnością przetwarzania elementów tablicy:
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
//
Przekazywanie tablic wielowymiarowych jako argumentów
Zainicjowana tablica wielowymiarowa jest przekazywana do metody w taki sam sposób, jak w przypadku przekazywania tablicy jednowymiarowej. Poniższy kod przedstawia częściową deklarację metody print, która akceptuje tablicę dwuwymiarową jako argument. Można zainicjować i przekazać nową tablicę w jednym kroku, jak pokazano w poniższym przykładzie. W poniższym przykładzie jest inicjowana dwuwymiarowa tablica liczb całkowitych i przekazywana Print2DArray do metody . Metoda wyświetla elementy tablicy.
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
*/
Tablice postrzępione
Tablica postrzępiona to tablica, której elementy są tablicami, prawdopodobnie o różnych rozmiarach. Tablica postrzępiona jest czasami nazywana "tablicą tablic". Jego elementy są typami referencyjnymi i są inicjowane na null. W poniższych przykładach pokazano, jak zadeklarować, zainicjować i uzyskać dostęp do tablic postrzępionych. Pierwszy przykład jaggedArray, jest zadeklarowany w jednej instrukcji. Każda zawarta tablica jest tworzona w kolejnych instrukcjach. Drugi przykład jaggedArray2 jest zadeklarowany i zainicjowany w jednej instrukcji. Można mieszać tablice postrzępione i wielowymiarowe. Ostatnim przykładem jest jaggedArray3deklaracja i inicjowanie jednowymiarowej tablicy postrzępionej, która zawiera trzy dwuwymiarowe elementy tablicy o różnych rozmiarach.
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);
Przed ich użyciem należy zainicjować elementy tablicy postrzępionej. Każda z tych elementów jest tablicą. Za pomocą inicjatorów można również wypełnić elementy tablicy wartościami. W przypadku używania inicjatorów nie potrzebujesz rozmiaru tablicy.
W tym przykładzie utworzono tablicę, której elementy są tablicami. Każdy z elementów tablicy ma inny rozmiar.
// 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
*/
Niejawnie wpisane tablice
Można utworzyć niejawnie typizowanej tablicy, w której typ wystąpienia tablicy jest wnioskowany z elementów określonych w inicjatorze tablicy. Reguły dla dowolnej niejawnie typizowanej zmiennej mają również zastosowanie do niejawnie wpisanych tablic. Aby uzyskać więcej informacji, zobacz Niejawnie wpisane zmienne lokalne.
W poniższych przykładach pokazano, jak utworzyć niejawnie typizowane tablicy:
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
*/
W poprzednim przykładzie zwróć uwagę, że w przypadku niejawnie wpisanych tablic nie są używane nawiasy kwadratowe po lewej stronie instrukcji inicjowania. Ponadto tablice postrzępione są inicjowane przy użyciu new [] tak samo jak tablice jednowymiarowe.
Podczas tworzenia typu anonimowego, który zawiera tablicę, tablica musi być niejawnie wpisywana w inicjatorze obiektu typu. W poniższym przykładzie contacts jest niejawnie typizowane tablicy typów anonimowych, z których każda zawiera tablicę o nazwie PhoneNumbers. Słowo var kluczowe nie jest używane wewnątrz inicjatorów obiektów.
var contacts = new[]
{
new
{
Name = "Eugene Zabokritski",
PhoneNumbers = new[] { "206-555-0108", "425-555-0001" }
},
new
{
Name = "Hanying Feng",
PhoneNumbers = new[] { "650-555-0199" }
}
};
