CSharp一维数组:多维数组:交错数组:三者对比分析

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

1. 数组定义

数组是存储相同类型数据的容器，数组长度固定不可变。

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：写法简单、代码少

• 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[,] → 1个逗号 → 二维数组（行+列，表格结构）

• int[,,] → 2个逗号 → 三维数组（块+行+列，立体结构）

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：获取数组维度数（二维返回2，三维返回3）

• Length：获取数组总元素个数（32位整型）

• LongLength：获取数组总元素个数（64位整型，适配超大数组）

• 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遍历
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]; // 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}";
    }
}
Console.WriteLine(names[3, 9]); // 读取指定位置数据

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

需求：初始化二维数组，指定 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();

// 随机生成合法下标：0 ~ 数组长度-1
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 };     // 长度4
int[] i2s = new int[] { 1, 2, 3, 4, 5 };    // 长度5

// 外层大数组，存放不同长度的小数组
int[][] ints = new int[][]
{
    i1s,
    i2s,
    new int[]{1,2,3,4,5,999} // 长度6
};

核心特征：内层数组长度 4、5、6 完全不统一，这就是交错数组。

三、交错数组 取值 & 赋值

1. 分步取值

先取出内层数组，再取数组内元素

int[] arr = ints[1];  // 取出第2个内层数组（i2s）
int a = arr[4];       // 取出该数组下标4的元素
Console.WriteLine(a);

2. 一键取值（常用）

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

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

3. 修改元素值

ints[1][2] = 888; // 修改指定外层、内层下标元素

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

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

外层循环：遍历外层大数组（ints.Length）

内层循环：遍历每一个内层小数组（ints[i].Length）

⚠️ 重点：内层长度不能写死，必须用 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简洁只读无下标

• 多维逗号规则表，行列长度都统一

• 交错括号数组套，内层长度不统一

• 多维取值逗号隔，交错取值双层括

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持本站。

您可能感兴趣的文章:

• 基于C#实现一维码和二维码打印功能
• 利用C#实现Word文档多维度信息统计
• C#实现获取多维数组的行数与列数
• C#中的矩形数组(多维数组)和锯齿数组的实现
• C#二维数组与多维数组的具体使用