C#教程

关注公众号 jb51net

关闭
首页 > 软件编程 > C#教程 > C#一维数组，多维数组，交错数组，三者对比

C#一维数组，多维数组，交错数组，三者对比分析

作者：z落落

本文详细解析了一维数组、多维数组和交错数组的核心概念、语法格式、取值赋值、遍历方式及常见错误点,助你全面掌握数组相关知识点,重点涵盖数组长度固定、取值格式、遍历技巧及交错数组的独特之处

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

1. 数组定义

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

2. 索引（下标）规则

3. 底层原理

所有数组都直接或间接继承自 Array 类，数组数据顺序连续存储。

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

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

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

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 终极区别（必背）

六、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

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

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

优点

缺点

多维数组（二维，三维）

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

1. 多维数组：二维及以上数组统称多维数组，是一维数组的扩展，用于存储结构化、立体化数据

2. 维度判定万能口诀：逗号个数 + 1 = 维度数

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列

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

所有多维数组通用，是遍历、取值的核心依据

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

完整测试代码

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. 定义

交错数组也叫锯齿数组：大数组里面存放的每一个元素，都是一个独立的小数组。

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

交错数组：每一个内层小数组的长度可以不相同（长短不一、参差不齐）

多维数组：每一行/列长度必须完全一致（规规矩矩的表格）

二、语法格式（必背）

1. 二维交错数组语法

格式：数据类型[][] 数组名

多个中括号：每一个中括号代表一层数组

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. 一维数组：单组数据
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. 长度获取区别

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

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

总结

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

您可能感兴趣的文章:
阅读全文