C# 数组
最后修改于 2025 年 5 月 7 日
在本文中，我们将探讨 C# 中的数组，这是一种用于有效存储多个元素的基本数据结构。
理解数组
数组是数据的结构化集合，允许在单个变量名下存储多个值。与一次只能保存一个值的标量变量不同，数组能够处理多个相关的值。数组中的每个值都称为元素。
数组存储相同数据类型的元素。这确保了类型安全和内存效率，因为数组中的所有元素都共享一个公共结构。每个元素都使用一个索引来访问，该索引标识其在数组中的位置。 C# 中的索引是从零开始的，这意味着数组的第一个元素位于索引 0 处，第二个元素位于索引 1 处，依此类推。
数组在 C# 中是引用类型，这意味着它们存储在堆内存中，而不是堆栈中。当数组传递给方法时，方法内部所做的修改会影响原始数组，因为只传递了一个引用。
声明数组
必须使用特定的数据类型声明数组，以确定它们可以存储的元素的类型。 C# 中的 Array 类提供了内置方法来有效地操作数组，包括排序、搜索和修改元素等操作。
int[] ages; string[] names; float[] weights;
每个数组声明都包含两个部分：元素的类型和数组名称。方括号 [] 的存在表示该变量是一个数组。例如，int[] ages 定义了一个整数数组，而 string[] names 存储多个字符串值。
数组 vs. 集合
虽然数组是存储多个值的简单有效方法，但 C# 中的集合提供了更大的灵活性和功能。 集合（例如 List<T> 或 Dictionary<TKey, TValue>）允许动态调整大小、高级搜索和更有效的数据操作。 与数组不同，集合不需要预定义的大小，使其更适应不断变化的数据要求。
理解数组及其功能对于有效地处理结构化数据至关重要。 虽然集合提供了更高级的功能，但数组仍然是 C# 编程中一种基本且高度优化的数据结构。
C# 初始化数组
我们可以通过几种方式在 C# 中初始化数组。
int[] vals = new int[5];
vals[0] = 1;
vals[1] = 2;
vals[2] = 3;
vals[3] = 4;
vals[4] = 5;
for (int i = 0; i < vals.Length; i++)
{
Console.WriteLine(vals[i]);
}
我们声明并初始化一个数值数组。 数组的内容被打印到控制台。
int[] vals = new int[5];
在这里，我们声明一个包含五个元素的数组。 所有元素都是整数。
vals[0] = 1; vals[1] = 2; ...
我们使用一些数据初始化数组。 这是赋值初始化。 索引在方括号中。 数字 1 将是数组的第一个元素，2 是第二个元素。
for (int i = 0; i < vals.Length; i++)
{
Console.WriteLine(vals[i]);
}
我们遍历数组并打印其元素。 数组有一个 Length 属性，它给出数组中的元素数量。 由于数组是从零开始的，因此索引是 0..length-1。
我们可以在一条语句中声明和初始化数组。
int[] array = new int[] { 2, 4, 5, 6, 7, 3, 2 };
foreach (int e in array)
{
Console.WriteLine(e);
}
这是上一个程序的修改版本。
int[] array = new int[] {2, 4, 5, 6, 7, 3, 2 };
在一个步骤中声明并初始化一个数组。 元素在花括号中指定。 我们没有指定数组的长度。 编译器会为我们做这件事。
foreach (int e in array)
{
Console.WriteLine(e);
}
我们使用 foreach 关键字来遍历数组并打印其内容。
简化的初始化语法
可以简化初始化语法。
int[] array = new int[] { 2, 4, 5, 6, 7, 3, 2 };
foreach (int e in array)
{
Console.WriteLine(e);
}
Console.WriteLine("------------------------------");
int[] array2 = { 2, 4, 5, 6, 7, 3, 2 };
foreach (int e in array2)
{
Console.WriteLine(e);
}
可以省略 new int[] 部分。
int[] array2 = { 2, 4, 5, 6, 7, 3, 2 };
int[] array2 = { 2, 4, 5, 6, 7, 3, 2 } 在内部编译为 int[] array2 = new int[] { 2, 4, 5, 6, 7, 3, 2 }。
数组初始值设定项
自 .NET 8 以来，我们可以使用集合初始值设定项来初始化数组。 该语法既可用于数组也可用于列表。
int[] vals = [1, 2, 3, 4, 5];
for (int i = 0; i < vals.Length; i++)
{
Console.WriteLine(vals[i]);
}
在该程序中，我们使用新语法创建并初始化数组。
int[] vals = [1, 2, 3, 4, 5];
此语法更短，在许多编程语言中都很常见。 它既用于列表。
C# Array.Fill
Array.Fill 方法使用给定的值填充整个数组。
int[] vals = new int[10];
Array.Fill(vals, 0);
Console.WriteLine(string.Join(", ", vals));
我们创建一个整数数组； 该数组填充了零。
$ dotnet run 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
C# 数组访问元素
创建数组后，可以通过其索引访问其元素。 索引是放在方括号内的数字，后跟数组名称。
我们可以使用从末尾开始的索引 ^ 运算符来获取数组末尾的元素。 ^0 等于 array.Length，^n 等于 array.Length - n。
string[] names = ["Jane", "Thomas", "Lucy", "David"];
Console.WriteLine(names[0]);
Console.WriteLine(names[1]);
Console.WriteLine(names[2]);
Console.WriteLine(names[3]);
Console.WriteLine("*************************");
Console.WriteLine(names[^1]);
Console.WriteLine(names[^2]);
Console.WriteLine(names[^3]);
Console.WriteLine(names[^4]);
在该示例中，我们创建一个字符串名称数组。 我们通过其索引访问每个元素并将它们打印到终端。
string[] names = { "Jane", "Thomas", "Lucy", "David" };
创建一个字符串数组。
Console.WriteLine(names[0]); Console.WriteLine(names[1]); Console.WriteLine(names[2]); Console.WriteLine(names[3]);
数组的每个元素都打印到控制台。 使用 names[0] 构造，我们引用 names 数组的第一个元素。
Console.WriteLine(names[^1]); Console.WriteLine(names[^2]); Console.WriteLine(names[^3]); Console.WriteLine(names[^4]);
我们从末尾访问数组元素。
$ dotnet run Jane Thomas Lucy David ************************* David Lucy Thomas Jane
C# 隐式类型数组
C# 可以推断数组的类型。
var vals = new[] { 1, 2, 3, 4, 5 };
var words = new[] { "cup", "falcon", "word", "water" };
Console.WriteLine(vals.GetType());
Console.WriteLine(words.GetType());
我们创建两个隐式类型数组。
var vals = new[] { 1, 2, 3, 4, 5 };
创建一个整数数组。 我们没有指定数组的类型； 编译器可以从赋值的右侧推断类型。 请注意，这里我们不能使用简化的语法或集合初始值设定项，因为我们需要告诉编译器集合的类型。
Console.WriteLine(vals.GetType()); Console.WriteLine(words.GetType());
使用 GetType，我们验证数组的数据类型。
$ dotnet run System.Int32[] System.String[]
C# 数组修改元素
可以修改数组的元素 - 它们不是不可变的。
int[] vals = [1, 2, 3, 4];
vals[0] *= 2;
vals[1] *= 2;
vals[2] *= 2;
vals[3] *= 2;
Console.WriteLine("[{0}]", string.Join(", ", vals));
我们有一个包含三个整数的数组。 每个值都将乘以二。
int[] vals = [1, 2, 3, 4];
创建一个包含四个整数的数组。
vals[0] *= 2; vals[1] *= 2; vals[2] *= 2; vals[3] *= 2;
使用元素访问，我们将数组中的每个值乘以 2。
Console.WriteLine("[{0}]", string.Join(", ", vals));
使用 Join 方法，我们从数组的所有元素创建一个字符串。 这些元素用逗号字符分隔。
$ dotnet run [2, 4, 6, 8]
所有四个整数都乘以了数字 2。
C# 数组切片
我们可以使用 .. 运算符来获取数组切片。 范围指定范围的开始和结束。 范围的开始是包含性的，但范围的结束是排他性的。 这意味着开始包含在范围内，但结束不包含在范围内。
int[] vals = [1, 2, 3, 4, 5, 6, 7];
int[] vals2 = vals[1..5];
Console.WriteLine("[{0}]", string.Join(", ", vals2));
int[] vals3 = vals[..6];
Console.WriteLine("[{0}]", string.Join(", ", vals3));
int[] vals4 = vals[3..];
Console.WriteLine("[{0}]", string.Join(", ", vals4));
该示例使用数组范围。
int[] vals2 = vals[1..5];
我们创建一个包含从索引 1 到索引 4 的元素的数组切片。
int[] vals3 = vals[..6];
如果省略起始索引，则切片从索引 0 开始。
int[] vals4 = vals[3..];
如果省略结束索引，则切片一直延伸到数组的末尾。
$ dotnet run [2, 3, 4, 5] [1, 2, 3, 4, 5, 6] [4, 5, 6, 7]
C# 遍历数组
我们经常需要遍历数组的所有元素。 我们展示了两种遍历数组的常用方法。
string[] planets = [ "Mercury", "Venus", "Mars",
"Earth", "Jupiter", "Saturn", "Uranus", "Neptune", "Pluto" ];
for (int i = 0; i < planets.Length; i++)
{
Console.WriteLine(planets[i]);
}
foreach (string planet in planets)
{
Console.WriteLine(planet);
}
创建一个行星名称数组。 我们使用 for 和 foreach 语句来打印所有值。
for (int i = 0; i < planets.Length; i++)
{
Console.WriteLine(planets[i]);
}
在此循环中，我们利用了可以从数组对象获取元素数量这一事实。 元素的数量存储在 Length 属性中。
foreach (string planet in planets)
{
Console.WriteLine(planet);
}
在遍历数组或其他集合时，可以使用 foreach 语句使代码更紧凑。 在每个循环中，planet 变量都会传递来自 planets 数组的下一个值。
C# 将数组作为函数参数传递
数组通过引用传递给函数。 这意味着可以更改原始数组的元素。
int[] vals = [1, 2, 3, 4, 5];
ModifyArray(vals);
Console.WriteLine(string.Join(", ", vals));
void ModifyArray(int[] data)
{
Array.Reverse(data);
}
我们将一个整数数组传递给 ModifyArray 函数。 它反转数组元素。 由于传递的是数组的引用而不是副本，因此 vals 数组已更改。
$ dotnet run 5, 4, 3, 2, 1
C# 数组维度
到目前为止，我们已经使用了一维数组。 指定元素所需的索引数量称为数组的维度或秩。
二维数组
接下来，我们使用二维数组。
int[,] twodim = new int[,] { { 1, 2, 3 }, { 1, 2, 3 } };
int d1 = twodim.GetLength(0);
int d2 = twodim.GetLength(1);
for (int i = 0; i < d1; i++)
{
for (int j = 0; j < d2; j++)
{
Console.WriteLine(twodim[i, j]);
}
}
如果我们需要两个索引来访问数组中的元素，那么我们就有一个二维数组。
int[,] twodim = new int[,] { { 1, 2, 3 }, { 1, 2, 3 } };
我们在一条语句中声明并初始化一个二维数组。 请注意方括号内的逗号。
int d1 = twodim.GetLength(0); int d2 = twodim.GetLength(1);
我们获取数组的维度。 GetLength 获取数组指定维度中的元素数量。
for (int i = 0; i < d1; i++)
{
for (int j = 0; j < d2; j++)
{
Console.WriteLine(twodim[i, j]);
}
}
我们使用两个 for 循环来遍历二维数组的所有元素。 请注意，使用两个由逗号字符分隔的索引来获取特定的数组元素。
$ dotnet run 1 2 3 1 2 3
我们可以使用 foreach 循环遍历二维数组。
int[,] vals = new int[4, 2]
{
{ 9, 99 },
{ 3, 33 },
{ 4, 44 },
{ 1, 11 }
};
foreach (var val in vals)
{
Console.WriteLine(val);
}
使用 foreach 循环，我们从头到尾一个一个地获取元素。
$ dotnet run 9 99 3 33 4 44 1 11
三维数组
接下来，我们使用三维数组。
int[,,] n3 =
{
{{12, 2, 8}},
{{14, 5, 2}},
{{3, 26, 9}},
{{4, 11, 2}}
};
int d1 = n3.GetLength(0);
int d2 = n3.GetLength(1);
int d3 = n3.GetLength(2);
for (int i = 0; i < d1; i++)
{
for (int j = 0; j < d2; j++)
{
for (int k = 0; k < d3; k++)
{
Console.Write(n3[i, j, k] + " ");
}
}
}
Console.Write('\n');
我们有一个数值三维数组。 同样，我们使用数字初始化数组并将它们打印到终端。
int[,,] n3 = {
{{12, 2, 8}},
{{14, 5, 2}},
{{3, 26, 9}},
{{4, 11, 2}}
};
左侧的方括号之间和右侧的附加花括号之间还有另一个逗号。
for (int k=0; k<d3; k++)
{
Console.Write(n3[i, j, k] + " ");
}
此循环遍历第三个维度。 我们使用三个索引从数组中检索值。
$ dotnet run 12 2 8 14 5 2 3 26 9 4 11 2
C# 秩
有一个 Rank 属性，它给出数组的维度数。
int[] a1 = { 1, 2 };
int[,] a2 = { { 1 }, { 2 } };
int[,,] a3 = { { { 1, 2 }, { 2, 1 } } };
Console.WriteLine(a1.Rank);
Console.WriteLine(a2.Rank);
Console.WriteLine(a3.Rank);
我们有三个数组。 我们使用 Rank 属性获取它们的维度数。
Console.WriteLine(a1.Rank);
在这里，我们获取第一个数组的秩。
$ dotnet run 1 2 3
C# 交错数组
具有相同大小元素的数组称为矩形数组。 相比之下，具有不同大小元素的数组称为交错数组。 交错数组以不同的方式声明和初始化。
int[][] jagged = new int[][]
{
new int[] { 1, 2 },
new int[] { 1, 2, 3 },
new int[] { 1, 2, 3, 4 }
};
foreach (int[] array in jagged)
{
foreach (int e in array)
{
Console.Write(e + " ");
}
}
Console.Write('\n');
这是交错数组的示例。
int[][] jagged = new int[][]
{
new int[] { 1, 2 },
new int[] { 1, 2, 3 },
new int[] { 1, 2, 3, 4 }
};
这是交错数组的声明和初始化。 请注意，这次我们使用了两对方括号。 我们有一个数组的数组。 更具体地说，我们已声明一个数组具有三个 int 数据类型的数组。 每个数组具有不同数量的元素。
foreach (int[] array in jagged)
{
foreach (int e in array)
{
Console.Write(e + " ");
}
}
我们使用两个 foreach 循环来遍历交错数组。 在第一个循环中，我们获取数组。 在第二个循环中，我们获取所获取数组的元素。
C# 数组排序和反转
Array.sort 方法对数组元素进行就地排序。 Array.Reverse 方法反转数组元素的顺序。
string[] names = ["Jane", "Frank", "Alice", "Tom"];
Array.Sort(names);
foreach (string e in names)
{
Console.Write(e + " ");
}
Console.Write('\n');
Array.Reverse(names);
foreach (string e in names)
{
Console.Write(e + " ");
}
Console.Write('\n');
在本示例中，我们对字符串数组进行排序和反转。
string[] names = ["Jane", "Frank", "Alice", "Tom"];
我们有一个字符串数组。
Array.Sort(names);
静态 Sort 方法按字母顺序对数据进行排序。
Array.Reverse(names);
Reverse 方法反转整个一维数组中元素的顺序。
$ dotnet run Alice Frank Jane Tom Tom Jane Frank Alice
或者，我们可以使用 LINQ 的 Order 和 OrderDescending 方法对数组进行排序。
string[] names = ["Jane", "Frank", "Alice", "Tom"];
var sorted = names.Order();
foreach (var name in sorted)
{
Console.WriteLine(name);
}
Console.WriteLine("----------------------");
var sorted2 = names.OrderDescending();
foreach (var name in sorted2)
{
Console.WriteLine(name);
}
该程序按升序和降序对字符串数组进行排序。
$ dotnet run Alice Frank Jane Tom ---------------------- Tom Jane Frank Alice
C# 数组 GetValue & SetValue
SetValue 方法将值设置为指定位置的元素。 GetValue 获取指定位置的值。
string[] names = ["Jane", "Frank", "Alice", "Tom"];
names.SetValue("Beky", 1);
names.SetValue("Erzebeth", 3);
Console.WriteLine(names.GetValue(1));
Console.WriteLine(names.GetValue(3));
此示例使用 SetValue 和 GetValue 方法。
names.SetValue("Beky", 1);
names.SetValue("Erzebeth", 3);
SetValue 为数组中的特定索引设置一个值。
Console.WriteLine(names.GetValue(1)); Console.WriteLine(names.GetValue(3));
我们使用 GetValue 方法从数组中检索值。
$ dotnet run Beky Erzebeth
C# 数组搜索
Array 类提供了几种用于搜索数组中元素的方法，例如 IndexOf、Exists 和 Find。
string[] fruits = ["apple", "banana", "cherry", "date", "elderberry"];
int bananaIndex = Array.IndexOf(fruits, "banana");
Console.WriteLine($"Index of 'banana': {bananaIndex}");
Console.WriteLine($"Index of 'grape': {grapeIndex}");
bool hasShortName = Array.Exists(fruits, fruit => fruit.Length < 5);
Console.WriteLine($"Any fruit with name shorter than 5 chars? {hasShortName}");
string startsWithC = Array.Find(fruits, fruit =>
fruit.StartsWith("c", StringComparison.OrdinalIgnoreCase));
Console.WriteLine($"First fruit starting with 'c': {startsWithC}");
此示例演示如何使用 Array.IndexOf 搜索元素，使用 Array.Exists 检查是否存在，以及使用 Array.Find 查找元素。
int bananaIndex = Array.IndexOf(fruits, "banana");
Array.IndexOf 返回 fruits 数组中 "banana" 第一次出现的从零开始的索引。 如果未找到该项目，则返回 -1。
bool hasShortName = Array.Exists(fruits, fruit => fruit.Length < 5);
Array.Exists 检查 fruits 数组中是否Any元素满足给定的谓词（在本例中为 lambda 表达式，检查水果名称的长度是否小于 5）。
string startsWithC = Array.Find(fruits, fruit =>
fruit.StartsWith("c", StringComparison.OrdinalIgnoreCase));
Array.Find 返回 fruits 数组中与 lambda 表达式指定的条件匹配的第一个元素（水果名称以“c”开头）。 如果未找到此类元素，则返回该类型的默认值（字符串为 null）。
$ dotnet run Index of 'banana': 1 Index of 'grape': -1 Any fruit with name shorter than 5 chars? True First fruit starting with 'c': cherry
C# 数组调整大小
C# 中的数组在创建后大小是固定的。 但是，可以使用 Array.Resize 方法创建一个具有不同大小的新数组，并将元素从旧数组复制到新数组。
int[] numbers = [10, 20, 30];
Console.WriteLine($"Original array: [{string.Join(", ", numbers)}], Size: {numbers.Length}");
Array.Resize(ref numbers, 5);
numbers[3] = 40;
numbers[4] = 50;
Console.WriteLine($"Resized (larger) array: [{string.Join(", ", numbers)}], Size: {numbers.Length}");
Array.Resize(ref numbers, 2);
Console.WriteLine($"Resized (smaller) array: [{string.Join(", ", numbers)}], Size: {numbers.Length}");
该示例演示如何使用 Array.Resize 更改数组的大小。 使用 ref 关键字是因为 Array.Resize 可能会将新的数组实例分配给变量。
Array.Resize(ref numbers, 5);
这将调整 numbers 数组的大小以使其具有 5 个元素。 如果新大小大于原始大小，则会复制现有元素，并将新元素初始化为其默认值（整数为 0）。
Array.Resize(ref numbers, 2);
这将调整 numbers 数组的大小以使其具有 2 个元素。 如果新大小较小，则会将原始数组中的元素复制到新大小，并截断其余元素。
$ dotnet run Original array: [10, 20, 30], Size: 3 Resized (larger) array: [10, 20, 30, 40, 50], Size: 5 Resized (smaller) array: [10, 20], Size: 2
C# 记录数组
C# 中的数组可以存储任何类型的元素，包括用户定义的记录。 通过使用 record 类型而不是类，开发人员可以创建不可变且简洁的数据结构，从而提高效率和可读性。
Person[] people = new Person[]
{
new("Alice", 30),
new("Bob", 24),
new("Charlie", 35)
};
Console.WriteLine("Array of Person records:");
foreach (Person person in people)
{
Console.WriteLine(person);
}
// Using collection initializer syntax (C# 12)
Person[] students =
[
new("David", 21),
new("Eve", 22)
];
Console.WriteLine("\nArray of Student records (initialized differently):");
foreach (Person student in students)
{
Console.WriteLine(student);
}
record Person(string Name, int Age);
此示例定义了一个 Person 记录，然后创建一个数组来存储此记录类型的实例。 记录简化了对象创建，并自动处理基于值的相等性和 ToString() 表示。
Person[] people = new Person[]
{
new("Alice", 30),
new("Bob", 24),
new("Charlie", 35)
};
声明了一个名为 people 的数组来保存 Person 记录。 每个元素都使用 C# 记录提供的简洁语法进行初始化。
Person[] students =
[
new("David", 21),
new("Eve", 22)
];
这演示了集合表达式语法（在 C# 12 中引入），用于更简洁地初始化记录数组。
$ dotnet run
Array of Person records:
Person { Name = Alice, Age = 30 }
Person { Name = Bob, Age = 24 }
Person { Name = Charlie, Age = 35 }
Array of Student records (initialized differently):
Person { Name = David, Age = 21 }
Person { Name = Eve, Age = 22 }
C# 转换数组和使用 LINQ
数组可以轻松转换为其他集合类型，如 List<T>。 此外，语言集成查询 (LINQ) 提供了强大的功能来查询和操作数组。
int[] numbers = [5, 1, 8, 2, 9, 4, 7, 3, 6];
Console.WriteLine($"Original array: [{string.Join(", ", numbers)}]");
List<int> numberList = numbers.ToList();
Console.WriteLine($"Converted to List, Count: {numberList.Count}");
numberList.Add(10);
Console.WriteLine($"List after adding 10: [{string.Join(", ", numberList)}]");
var evenNumbers = numbers.Where(n => n % 2 == 0);
Console.WriteLine($"Even numbers: [{string.Join(", ", evenNumbers)}]");
var squaredNumbers = numbers.Select(n => n * n);
Console.WriteLine($"Squared numbers: [{string.Join(", ", squaredNumbers)}]");
var filteredAndSorted = numbers.Where(n => n > 5)
.OrderBy(n => n);
Console.WriteLine($"Numbers > 5, sorted: [{string.Join(", ", filteredAndSorted)}]");
int sum = numbers.Sum();
Console.WriteLine($"Sum of elements: {sum}");
bool anyGreaterThanEight = numbers.Any(n => n > 8);
Console.WriteLine($"Any element > 8? {anyGreaterThanEight}");
此示例演示了将数组转换为 List<int>，然后展示了一些 LINQ 方法，如 Where、Select、OrderBy、Sum 和 Any，以对数组执行常见的数据操作任务。
ListnumberList = numbers.ToList();
ToList LINQ 扩展方法将 numbers 数组转换为 List<int>。 列表提供动态调整大小和其他数组直接不可用的方法。
var evenNumbers = numbers.Where(n => n % 2 == 0);
Where LINQ 方法根据谓词过滤数组。 在这里，它仅选择偶数。
var squaredNumbers = numbers.Select(n => n * n);
Select LINQ 方法将数组的每个元素投影成一种新形式。 在这里，它对每个数字进行平方。
var filteredAndSorted = numbers.Where(n => n > 5)
.OrderBy(n => n);
LINQ 方法可以链接在一起。 此示例首先过滤大于 5 的数字，然后按升序对结果进行排序。
$ dotnet run Original array: [5, 1, 8, 2, 9, 4, 7, 3, 6] Converted to List, Count: 9 List after adding 10: [5, 1, 8, 2, 9, 4, 7, 3, 6, 10] Even numbers: [8, 2, 4, 6] Squared numbers: [25, 1, 64, 4, 81, 16, 49, 9, 36] Numbers > 5, sorted: [6, 7, 8, 9] Sum of elements: 45 Any element > 8? True
C# 数组克隆 & 清除
Array.Copy 方法将值从源数组复制到目标数组。 Array.Clear 删除数组的所有元素。
string[] names = ["Jane", "Frank", "Alice", "Tom"];
string[] names2 = new string[4];
Array.Copy(names, names2, names.Length);
Console.WriteLine(string.Join(", ", names2));
Array.Clear(names2);
Console.WriteLine(string.Join(", ", names2));
在该程序中，我们创建了一个数组的副本，然后删除它。
Array.Copy(names, names2, names.Length);
Copy 方法将值从源数组复制到目标数组。 第一个参数是源数组，第二个是目标数组。 第三个参数是长度；它指定要复制的元素数。
Array.Clear(names2);
Clear 方法删除数组中的所有元素。
$ dotnet run Jane, Frank, Alice, Tom , , ,
来源
在本文中，我们使用了 C# 中的数组。
作者
列出所有 C# 教程。