掌握 C# 锯齿数组：声明、初始化与访问完全指南

C# 锯齿数组

本教程讲解 C# 锯齿数组的声明、初始化与访问，配以实战示例。

C# 中，锯齿数组由多个数组作为元素组成。与多维数组不同，锯齿数组内部的每个数组大小可以不同。

学习锯齿数组前，请确保了解：

C# 数组
C# 多维数组

锯齿数组声明

声明锯齿数组的语法：

dataType[ ][ ] nameOfArray = new dataType[rows][ ];

示例：

// 声明锯齿数组
int[ ][ ] jaggedArray = new int[2][ ];

其中：

int - 数组数据类型
[][] - 表示锯齿数组
jaggedArray - 数组名称
[2][] - 表示锯齿数组包含 2 个元素（即 2 个数组）

因为每个元素本身是数组，可单独设定其大小：

// 设置第一个数组大小为 3
jaggedArray[0] = new int[3];
// 设置第二个数组大小为 2
jaggedArray[1] = new int[2];

初始化锯齿数组

有多种初始化方式：

1. 使用索引逐个赋值

// 初始化第一个数组
jaggedArray[0][0] = 1;
jaggedArray[0][1] = 3;
jaggedArray[0][2] = 5;
// 初始化第二个数组
jaggedArray[1][0] = 2;
jaggedArray[1][1] = 4;

其中：

第一个方括号索引代表锯齿数组元素的索引
第二个方括号索引代表各内部数组内元素的索引

2. 声明时直接初始化内部数组（无需预设大小）

// 声明字符串锯齿数组
int[ ][ ] jaggedArray = new int[2] [ ];
// 初始化每个数组
jaggedArray[0] = new int[] {1, 3, 5};
jaggedArray[1] = new int[] {2, 4};

3. 声明时完整初始化

int[ ][ ] jaggedArray = { new int[ ] {10, 20, 30}, new int[ ] {11, 22}, new int[ ] {88, 99} };

访问锯齿数组元素

使用索引访问：

// 访问第二个数组的第一个元素
jaggedArray[1][0];
// 访问第二个数组的第二个元素
jaggedArray[1][1];
// 访问第一个数组的第二个元素
jaggedArray[0][1];

示例：C# 锯齿数组

using System;
namespace JaggedArray {
    class Program {
        static void Main(string[] args) {
            // 创建锯齿数组
            int[ ][ ] jaggedArray = { new int[] {1, 3, 5}, new int[] {2, 4}, };
            // 打印元素
            Console.WriteLine("jaggedArray[1][0]: " + jaggedArray[1][0]);
            Console.WriteLine("jaggedArray[1][1]: " + jaggedArray[1][1]);
            Console.WriteLine("jaggedArray[0][2]: " + jaggedArray[0][2]);
            Console.ReadLine();
        }
    }
}

输出

jaggedArray[1][0]: 2
jaggedArray[1][1]: 4
jaggedArray[0][2]: 5

此例中锯齿数组内部：

jaggedArray[1][0] - 第二个数组的第一个元素
jaggedArray[1][1] - 第二个数组的第二个元素
jaggedArray[0][2] - 第一个数组的第三个元素

遍历锯齿数组

可用循环遍历锯齿数组每个元素：

using System;
namespace JaggedArray {
    class Program {
        static void Main(string[] args) {
            // 声明锯齿数组
            int[][] jaggedArray = new int[2][];
            // 设置锯齿数组元素大小
            jaggedArray[0] = new int[3];
            jaggedArray[1] = new int[2];
            // 初始化第一个数组
            jaggedArray[0][0] = 1;
            jaggedArray[0][1] = 3;
            jaggedArray[0][2] = 5;
            // 初始化第二个数组
            jaggedArray[1][0] = 2;
            jaggedArray[1][1] = 2;
            // 外层 for 循环
            for (int i = 0; i < jaggedArray.Length; i++) {
                Console.Write("Element " + i + ": ");
                // 内层 for 循环
                for (int j = 0; j < jaggedArray[i].Length; j++) {
                    Console.Write(jaggedArray[i][j] + " ");
                }
                Console.WriteLine();
            }
            Console.ReadLine();
        }
    }
}

输出

Element 0: 1 3 5
Element 1: 2 2

此例使用嵌套 for 循环遍历：

1. 外层 for 循环

访问锯齿数组的元素（即内部数组）
jaggedArray.Length - 获取锯齿数组大小（内部数组个数）

2. 内层 for 循环

访问各内部数组的元素
jaggedArray[i].Length - 获取第 i 个内部数组的大小

锯齿数组与多维数组结合

C# 中也可将多维数组作为锯齿数组元素：

int[ ][ , ] jaggedArrayTwoD = new int[2][ , ] {
    new int[,] { {1, 8}, {6, 7} },
    new int[,] { {0, 3}, {5, 6}, {9, 10} }
};

每个锯齿数组元素是一个多维数组：

new int[,] { {1, 8}, {6, 7} } - 含 2 行的二维数组
new int[ , ] { {0, 3}, {5, 6}, {9, 10} } - 含 3 行的二维数组

完整示例：

using System;
namespace JaggedArray {
    class Program {
        static void Main(string[] args) {
            // 声明并初始化包含 2D 数组的锯齿数组
            int[][,] jaggedArray = new int[3][ , ] {
                new int[ , ] { {1, 8}, {6, 7} },
                new int[ , ] { {0, 3}, {5, 6}, {9, 10} },
                new int[ , ] { {11, 23}, {100, 88}, {0, 10} }
            };
            Console.WriteLine(jaggedArray[0][0, 1]);
            Console.WriteLine(jaggedArray[1][2, 1]);
            Console.WriteLine(jaggedArray[2][1, 0]);
            Console.ReadLine();
        }
    }
}

输出

8
10
100

注意代码 jaggedArray[0][0, 1]：

[0] - 锯齿数组的第一个元素（即第一个 2D 数组）
[0, 1] - 该 2D 数组第一行的第二个元素

C# 多维数组：二维数组详解与代码示例 C# foreach 循环：轻松遍历数组与集合

C语言