C#既然数组长度不可改变，那么如何动态调整集合类型数组大小，以便添加或删除元素？
目录
1.使用动态数组（ArrayList）：
2.使用 jagged array（不规则数组）：
3.使用 List ：
4.使用数组复制：
在C#中，数组的长度是固定的，一旦声明和初始化，就不能更改。但是，您可以使用其他集合类型，例如ArrayList或List<T>，这些类型可以动态调整大小以添加或删除元素。
1.使用动态数组（ArrayList）：
动态数组是一种可以在运行时改变大小的数组。当你需要添加或删除元素时，它会自动调整自身的大小。
// 使用 ArrayList 可以动态调整数组的大小。
using System.Collections;
namespace _106_8
{
class Program
{
static void Main(string[] args)
{
ArgumentNullException.ThrowIfNull(args);
// 初始化 ArrayList
ArrayList arrayList =
[
new int[] { 1, 2 },
new int[] { 3, 4, 5 },
new int[] { 6, 7, 8, 9 },
];
// 打印原始数组
Console.WriteLine("原始数组：");
PrintArray(arrayList);
// 添加新行
Console.WriteLine();
// 动态调整数组大小
arrayList.Capacity = 5;
// 初始化新数组
arrayList.Add(new int[] { 10, 11 });
arrayList.Add(new int[] { 12, 13, 14 });
// 打印调整大小后的数组
Console.WriteLine("调整大小后的数组：");
PrintArray(arrayList);
}
static void PrintArray(ArrayList array)
{
foreach (var row in array)
{
Console.Write("[" + string.Join(", ", (int[])row) + "]");
Console.WriteLine();
}
}
}
}
//运行结果：
/*
原始数组：
[1, 2]
[3, 4, 5]
[6, 7, 8, 9]
调整大小后的数组：
[1, 2]
[3, 4, 5]
[6, 7, 8, 9]
[10, 11]
[12, 13, 14]
*/2.使用 jagged array（不规则数组）：
jagged array 是一种数组的数组，它可以用来模拟可变大小的数组。jaggedArray 的大小是可变的，你可以根据需要改变它。
首先创建了一个 jagged array，并初始化了一些数据。然后，使用 ResizeArray 函数将 jaggedArray 的大小调整为 5，然后添加了一些新的数据。最后，使用 PrintArray 函数打印了调整大小后的数组。
注意，这种方法并不会真正改变 jagged array 中每个子数组的大小，而是通过创建一个新的 jagged array 来实现动态调整大小的效果。如果你需要在运行时真正地改变数组的大小，可以考虑使用其他数据结构，如动态数组（ArrayList）。
// 使用 jagged array（不规则数组）
// 可以实现动态调整数组大小的效果
namespace _106_7
{
class Program
{
static void Main(string[] args)
{
ArgumentNullException.ThrowIfNull(args);
// 初始化 jaggedArray
int[][] jaggedArray =
[
[1, 2],
[3, 4, 5],
[6, 7, 8, 9],
];
// 打印原始数组
Console.WriteLine("原始数组：");
PrintArray(jaggedArray);
// 添加新行
Console.WriteLine();
// 动态调整数组大小
jaggedArray = ResizeArray(jaggedArray, 5);
// 初始化新数组
jaggedArray[3] = [10, 11];
jaggedArray[4] = [12, 13, 14];
// 打印调整大小后的数组
Console.WriteLine("调整大小后的数组：");
PrintArray(jaggedArray);
}
static int[][] ResizeArray(int[][] jaggedArray, int newSize)
{
int[][] newArray = new int[newSize][];
Array.Copy(jaggedArray, newArray, Math.Min(jaggedArray.Length, newSize));
return newArray;
}
static void PrintArray(int[][] array)
{
foreach (var row in array)
{
Console.Write("[" + string.Join(", ", row) + "]");
Console.WriteLine();
}
}
}
}
//运行结果：
/*
原始数组：
[1, 2]
[3, 4, 5]
[6, 7, 8, 9]
调整大小后的数组：
[1, 2]
[3, 4, 5]
[6, 7, 8, 9]
[10, 11]
[12, 13, 14]
*/3.使用 List<T> ：
使用 List<T> 也可以动态调整数组的大小。
首先创建了一个 List<int[]>，并初始化了一些数据。然后，使用 Capacity 属性将 List<int[]> 的大小调整为 5，然后添加了一些新的数据。最后，我们使用 PrintArray 函数打印了调整大小后的数组。
注意，这种方法会真正地改变 List<int[]> 中每个子数组的大小，因为它会动态地分配和释放内存。但是，由于 List<int[]> 是基于对象的，所以它比数组更慢，如果你需要更高的性能，可以考虑使用其他数据结构，如数组。
// 使用 List<T> 也可以动态调整数组的大小
namespace _106_9
{
class Program
{
static void Main(string[] args)
{
ArgumentNullException.ThrowIfNull(args);
// 初始化 List<int[]>
List<int[]> list =
[
[1, 2],
[3, 4, 5],
[6, 7, 8, 9],
];
// 打印原始数组
Console.WriteLine("原始数组：");
PrintArray(list);
// 添加新行
Console.WriteLine();
// 动态调整数组大小
list.Capacity = 5;
// 初始化新数组
list.Add([10, 11]);
list.Add([12, 13, 14]);
// 打印调整大小后的数组
Console.WriteLine("调整大小后的数组：");
PrintArray(list);
}
static void PrintArray(List<int[]> list)
{
foreach (var row in list)
{
Console.Write("[" + string.Join(", ", row) + "]");
Console.WriteLine();
}
}
}
}
//运行结果：
/*
原始数组：
[1, 2]
[3, 4, 5]
[6, 7, 8, 9]
调整大小后的数组：
[1, 2]
[3, 4, 5]
[6, 7, 8, 9]
[10, 11]
[12, 13, 14]
*/4.使用数组复制：
创建一个新的数组，将旧数组的元素复制到新数组中，然后释放旧数组。这是一种比较低效的方法，但在某些情况下可能会有用。
// 复制旧数组并增加数组长度
namespace _106_7
{
class Program
{
static void Main(string[] args)
{
ArgumentNullException.ThrowIfNull(args);
int[] oldArray = new int[10];
//... 初始化 oldArray
int[] newArray = new int[oldArray.Length * 2];
Array.Copy(oldArray, newArray, oldArray.Length);
int newlength = newArray.Length;
Console.WriteLine("新数组长度= {0}", newlength);
}
}
}
//运行结果：
/*
新数组长度= 20
*/