C#一维、多维与交错数组对比分析

一、数组核心概念（必考）

我们从最基础的知识讲起。数组究竟是什么？简单来说，它是一个专门用于存储同一类型数据的容器。而且这个容器的“大小”，即长度，是一旦创建就固定不变的。这一点必须牢记在心。

它之所以被称为“数组”，本质上就是一组数据的集合。你可能会问：“那数组里的数据如何访问呢？”这就涉及到索引的概念。

2. 索引（下标）规则

• 索引从 0 开始计数。
• 数组的“长度”是从 1 开始计算的。
• 因此，最大的索引号 = 数组长度 - 1。

3. 底层原理

数组在底层是如何工作的？你可以把它想象成一条整齐排列的街道，每个门牌号一一对应。所有数组，无论哪种类型，都直接或间接继承自 Array 类，并且数据在内存中是顺序连续存储的。

4. 数组最大特点（重中之重）

它的最大特点，也是最需要注意的地方：

• 长度固定，一旦创建无法更改。
• 所有数据在内存中 连续存储。
• 只能通过 下标 来操作元素。
• 所有数组都是 Array 的子类。

二、各类数组默认值（必背）

当你创建一个空数组，尚未放入数据时，系统会自动填充“默认值”。编写代码时，千万别以为里面是空的。例如：

• int[] 默认值为 0
• double[] 默认值也是 0
• bool[] 默认值为 false
• string[] 默认值为 null
• char[] 默认值为 空字符
• object[] 默认值也是 null

这些默认值在面试时常被考到，因此务必记住。

三、数组四种定义+赋值方式（全覆盖）

1. 先定义、后开辟空长度

int[] ages;
ages = new int[10]; // 先声明变量，再为其分配10个位置

2. 指定长度 + 初始化元素

string[] names = new string[5] { "张三", "张三", "张三", "张三", "张三" };

规则：定义的长度必须与{}里的元素个数一致，一旦数量不匹配，编译器直接报错。

3. 不指定长度，自动匹配元素个数

int[] ages = new int[] { 1, 2, 3 };

4. 最简字面量定义（最常用）

int[] nums = { 1, 2, 3 };

四、数组元素赋值与取值

1. 单个赋值

string[] msgs = new string[100];
msgs[0] = "张三";
msgs[1] = "搜索";

2. 循环批量赋值

for (int i = 0; i < msgs.Length; i++)
{
    msgs[i] = i + "深度";
}

msgs.Length 这个属性很关键，它直接返回数组的总长度。注意，此属性是只读的。

3. 取值

Console.WriteLine(msgs[99]); // 通过下标取出对应位置的值

五、数组两种遍历方式（重点对比）

1. for循环遍历

for (int i = 0; i < msgs.Length; i++)
{
    Console.WriteLine(msgs[i] + "--------");
}

优点：你可以获取当前是第几个元素（下标i），也可以直接修改数组里的数据。

2. foreach遍历

foreach (string item in msgs)
{
    Console.WriteLine(item + "++++");
}

这里的item，就相当于 msgs[i]，代表你当前遍历到的那个元素。

3. for 和 foreach 终极区别（必背）

• for：功能强大，能获取下标、能修改元素，非常灵活。
• foreach：语法简洁、代码量少，但它的局限也很明显：无法获取下标，也不能修改原数组里的元素。

六、object万能数组（了解+必考选择题）

普通数组只能存放一种类型，但object数组不同，它像一个“万能容器”，什么都能放进去：

object[] arr = new object[5] { 1, 2, 3, "张三", true };

foreach (object item in arr)
{
    Console.WriteLine(item);
}

缺点：取出来的数据都是object类型，如果想进行运算，必须先强制转换成你需要的类型。

另外，直接输出数组名，比如 Console.WriteLine(arr)，你看到的不会是里面的元素，而是 System.Object[]。所有数组直接打印输出的都是类型名。

七、高频报错：索引超出数组界限

string[] msgs = new string[100];
msgs[100] = "ss"; // 报错！！

报错原因：长度是100，但下标范围只有 0 ~ 99，根本没有100这个下标。

记住一个口诀：下标最大 = 长度 - 1。

八、终极必背总结（默写短句）

• 数组：固定长度、存储同类型、下标从0开始
• int默认0、bool默认false、string默认null、char默认空
• 四种数组定义方式，长度可指定也可自动推断
• for可获取下标可修改，foreach简洁但不能获取下标不能修改
• object数组万能存储，但需要类型转换
• 禁止下标越界：最大下标=长度-1
• 直接打印数组名，输出数组类型名称

九、数组特点+优缺点总结

优点

• 查询速度快（通过下标直接定位，一步到位）
• 结构简单、顺序存储

缺点

• 长度固定，无法扩容
• 增删数据效率低（移动大量元素很费时）

多维数组（二维，三维）

一、多维数组核心概念（必背）

1. 多维数组，其实就是二维或以上的数组。它是一维数组的扩展，专门用于处理表格状、立体化的数据。

2. 如何判断一个数组是几维的？有个通用口诀：逗号个数 + 1 = 维度数。

• int[,] 有一个逗号，所以它是二维数组，有行有列，类似Excel表格。
• int[,,] 有两个逗号，那就是三维数组，像一个个立方体块，由块、行、列构成。

3. 它的通用特性与一维数组相同：长度固定、存储同类型、下标从0开始、内存连续。

二、多维数组两种定义方式（全覆盖）

1. 指定维度长度（空数组，后续赋值）

语法：数据类型[维度1,维度2...] 数组名 = new 数据类型[长度1,长度2...];

int[,] arr2 = new int[2, 3];   // 二维：2行3列
int[,,] arr3 = new int[2, 3, 4];// 三维：2块、3行、4列

2. 自动推导维度（初始化赋值，无需写长度）

只要你提供值，它自己就能判断出维度。

二维数组初始化案例

int[,] ints = new int[,]
{
    {1,2,3 },
    {4,5,6},
    {7,8,9},
};
// 自动识别为3行3列

三维数组初始化案例

int[,,] ints1 = new int[,,]
{
    { {1,2,3}, {1,2,3} },
    { {1,2,113}, {1,2,339} }
};
// 自动识别为2块、2行、3列

三、多维数组五大核心属性/方法（必考）

这几个属性和方法，是编写遍历和取值操作必备的工具。

• Rank：返回数组的维度数。
• Length：返回元素的总个数。
• LongLength：当数组非常大时，用此属性获取总个数。
• GetLength(n)：这个最常用，用于获取某个维度上的长度。

维度索引对应规则（死记）

• 二维数组：GetLength(0)=行数、GetLength(1)=列数
• 三维数组：GetLength(0)=块数、GetLength(1)=行数、GetLength(2)=列数
• 所有维度下标都是从0开始，最大值就是该维度长度-1。

完整测试代码

string[,] strings = new string[,]
{
    {"孙悟空","猪八戒","沙和尚" },
    {"刘备","曹操","孙权" },
    {"宋江","林冲","吴用" },
    {"贾宝玉","林黛玉","薛宝钗"}
};
Console.WriteLine(strings.Rank);         // 2
Console.WriteLine(strings.Length);       // 12
Console.WriteLine(strings.GetLength(0)); // 4
Console.WriteLine(strings.GetLength(1)); // 3

四、多维数组取值 & 赋值

1. 取值语法

二维就是 数组[行下标, 列下标]，三维就是 数组[块下标, 行下标, 列下标]。

Console.WriteLine(strings[0, 0]);    // 孙悟空
Console.WriteLine(strings[3, 1]);    // 林黛玉
Console.WriteLine(ints1[1, 1, 2]);   // 339

2. 赋值语法

五、多维数组两种遍历方式（大题必考）

1. 嵌套for循环（精准遍历，可改值、可定位）

当你需要区分行列、修改元素时，就用这种方式。

// 二维数组
for (int i = 0; i < strings.GetLength(0); i++)
{
    for (int j = 0; j < strings.GetLength(1); j++)
    {
        Console.Write(strings[i, j] + " ");
    }
    Console.WriteLine();
}

2. foreach遍历（简洁快速，只读遍历）

特性：无视所有维度，它会像扫地机器人一样，沿着内存顺序逐个将元素平铺输出。

缺点：无法获取下标，也不能修改数据。

foreach (var item in strings)
{
    Console.WriteLine(item);
}

六、动态批量赋值（空多维数组填充数据）

如果你先定义了一个空数组，再想填满它，就需要使用嵌套循环：

string[,] names = new string[5, 10];
for (int i = 0; i < names.GetLength(0); i++)
{
    for (int j = 0; j < names.GetLength(1); j++)
    {
        names[i, j] = $"行:{i} 列:{j}";
    }
}

七、经典定点赋值案例（考试常考）

例如，要求初始化一个二维数组，让 arr[0,3]=10、arr[1,2]=20、arr[2,2]=30，其他全是0。

int[,] ints2 = new int[,]
{
    {0,0,0,10},
    {0,0,20,0 },
    {0,0,30,0 }
};

八、拓展：多维数组+随机数实战（随机取值）

有时候，你想随机从数组里挑选一个名字，可以使用随机数来生成合法的下标：

string[] xings = {"赵","钱","孙","李","诸葛","夏侯","东方","欧阳"};
string[] names1 = { "亮", "娜娜", "月初", "惇", "匡胤", "多多", "权", "世民" };
Random rnd = new Random();

int index1 = rnd.Next(0, xings.Length);
int index2 = rnd.Next(0, names1.Length);
Console.WriteLine(xings[index1] + names1[index2]);

九、多维数组 高频易错点（扣分避坑）

• 1. 多维数组下标格式：[行,列]，千万不能写成 [i][j] 的形式。
• 2. 遍历时千万别用 数组名.Length 做循环条件，必须用 GetLength(维度)。
• 3. 下标越界：任意维度，最大下标 = 该维度长度 - 1。
• 4. foreach 遍历多维数组时，你不能区分行列，只能读取不能修改。
• 5. 多维数组初始化时，每一行的元素个数必须一致，否则编译器会报错。
• 6. 直接打印多维数组名，输出的也是类型名，不是元素内容。

十、终极默写短句（考前速记）

• 维度判定：逗号个数+1=维度数
• Rank取维度数，Length取总元素数，GetLength取单维度长度
• 二维0维是行、1维是列，三维0块1行2列
• 嵌套for可遍历可改值，foreach平铺只读无下标
• 多维下标逗号分隔，禁止多括号写法
• 所有维度下标从0开始，最大下标=维度长度-1

交错数组

一、交错数组核心概念（必考）

1. 定义

交错数组也叫锯齿数组，它就像一个大盒子，里面存放的每一个元素，都是一个独立的小盒子（小数组）。

2. 最核心特点（区别于多维数组）

关键就在这里：交错数组里的每个小数组，长度可以不一样。 这与多维数组那种每行必须等长的固定规则截然不同。

二、语法格式（必背）

1. 二维交错数组语法

格式：数据类型[][] 数组名。括号的个数，代表嵌套的层数。

• int[][] 是两层。
• int[][][] 就是三层。

2. 完整初始化方式

int[] i1s = new int[4] { 1, 2, 3, 4 };
int[] i2s = new int[] { 1, 2, 3, 4, 5 };

int[][] ints = new int[][]
{
    i1s,
    i2s,
    new int[]{1,2,3,4,5,999}
};

特别注意，这三个内层数组的长度分别是4、5、6，完全不一样，这正是交错数组的精髓所在。

三、交错数组 取值 & 赋值

1. 分步取值

int[] arr = ints[1];  // 先取出第2个小数组
int a = arr[4];       // 再取里面的第5个元素

2. 一键取值（常用）

数组[外层下标][内层下标]

Console.WriteLine(ints[2][5]); // 999

3. 修改元素值

ints[1][2] = 888;

四、交错数组两种遍历方式（大题必考）

1. 双层 for 循环遍历（重点）

这里有个很重要的地方：内层循环长度不能写死，必须用 ints[i].Length，因为每个小数组的长度都可能不同。

for (int i = 0; i < ints.Length; i++)
{
    Console.WriteLine("当前内层数组长度：" + ints[i].Length);
    for (int j = 0; j < ints[i].Length; j++)
    {
        Console.WriteLine($"({i}:{j}={ints[i][j]})");
    }
}

2. 双层 foreach 遍历

foreach (int[] item in ints)
{
    foreach (int item1 in item)
    {
        Console.WriteLine(item1 + "+++++++");
    }
}

五、交错数组必背易错点

• 1. 交错数组是 多括号 [][]，多维数组是 逗号 [,]，语法绝对不能搞混。
• 2. 最大特点：内层数组长度可以不同。
• 3. 遍历内层时，必须用 ints[i].Length，不能用固定值。
• 4. 取值格式是 [外层下标][内层下标]，不是逗号。
• 5. 多维数组是一整块规则表格；交错数组是数组的集合，独立性更强。

六、终极默写短句（考前速记）

• 交错数组数组套数组，双层括号[][]，长度参差不齐
• 多维数组逗号[,]，规则表格，行列长度统一
• 交错取值双层下标，多维取值逗号分隔
• 交错遍历内层长度随数组变化，不能写死

三种数组终极对比总结（一维、二维、交错）

// 1. 一维数组
int[] arr1 = new int[3] { 1, 2, 3 };
// 2. 二维多维数组
int[,] arr2 = new int[,] { {1,2,3}, {4,5,6} };
// 3. 二维交错数组
int[][] arr3 = new int[][] { new int[]{1,2}, new int[]{3,4,5,6} };

第一部分：三大数组终极对比（考试简答题满分）

1. 语法区别

• 一维数组：[]
• 多维数组：[,] 逗号分隔
• 交错数组：[][] 多括号嵌套

2. 结构区别

• 多维数组：所有行列长度统一，整体表格
• 交错数组：每行长度可以不一样

3. 取值区别

• 多维：[行,列]
• 交错：[外层][内层]

4. 长度获取区别

• 多维数组：GetLength(维度)
• 交错数组：外层.Length / 内层[i].Length

第二部分：数组全套易错点汇总（满分避坑）

• 1. 数组长度固定，不支持扩容
• 2. 所有下标遵循：最大下标 = 长度 - 1，禁止越界
• 3. 一维遍历用 Length，多维遍历必须用 GetLength()
• 4. 多维逗号[,]、交错双括号[][]，语法绝对不能混用
• 5. 交错数组内层长度不统一，遍历必须动态获取长度
• 6. foreach 遍历所有数组都是只读，不能修改原数据
• 7. 直接打印数组名输出类型，不输出元素

第三部分：终极默写短句（考前速记）

• 数组固定长度存同类，下标从零起，最大长度减一
• 数值默认0，布尔false，字符串null，字符空
• for带下标可改值，foreach简洁只读无下标
• 多维逗号规则表，行列长度都统一
• 交错括号数组套，内层长度不统一
• 多维取值逗号隔，交错取值双层括