Why we have both jagged array and multidimensional array?

锯齿数组是数组的数组。不能保证每个数组的大小相同。你本可以的

int[][] jaggedArray = new int[5][];
jaggedArray[0] = new[] {1, 2, 3}; // 3 item array
jaggedArray[1] = new int[10];     // 10 item array
// etc.

这是相关数组的 准备好了。

A multidimensional array, on the other hand, is more of a cohesive grouping, like a box, table, cube, etc., where there are no irregular lengths. That is to say

int i = array[1,10];
int j = array[2,10]; // 10 will be available at 2 if available at 1

1. 锯齿形数组是数组的数组，所以 int[][]是 int[]的数组，每个数组可以有不同的长度，并且在内存中占据自己的块。多维数组(int[,])是单个内存块(本质上是一个矩阵)。

2. You can't create a MyClass[10][20] because each sub-array has to be initialized separately, as they are separate objects:

   MyClass[][] abc = new MyClass[10][];
   
   
   for (int i=0; i<abc.Length; i++) {
   abc[i] = new MyClass[20];
   }
   

   MyClass[10,20]是可以的，因为它将一个对象初始化为一个包含10行20列的矩阵。

3. MyClass[][,][,]可以这样初始化(虽然没有经过编译测试) :

   MyClass[][,][,] abc = new MyClass[10][,][,];
   
   
   for (int i=0; i<abc.Length; i++) {
   abc[i] = new MyClass[20,30][,];
   
   
   for (int j=0; j<abc[i].GetLength(0); j++) {
   for (int k=0; k<abc[i].GetLength(1); k++) {
   abc[i][j,k] = new MyClass[40,50];
   }
   }
   }
   

Bear in mind, that the CLR is heavily optimized for single-dimension array access, so using a jagged array will likely be faster than a multidimensional array of the same size.

A rectangular array always has the same amount of columns for every row.

MyClass[,] x = new MyClass[10,30]

Every row has 30 columns, whereas in a jagged array, this is not required. 因此，我认为必须分别初始化锯齿数组中的每一行:

MyClass[][] x = new MyClass[10][];


for(int i = 0; i < 10; i++)
{
x[i] = new MyClass[30];
}

实际上，这意味着锯齿数组中的每一行必须包含相同数量的元素。(在我的示例中，它具有相同数量的元素，但不是必需的)。

你完全可以这样做，例如:

MyClass[][] x = new MyClass[10][];


for(int i = 0; i < 10; i++)
{
x[i] = new MyClass[(30 + i)];
}

这篇 可能对您来说是一篇有趣的文章。

如果您正在寻找具有设置边界的多维数组，请始终使用 [,]样式的语法。这将确保每个部分的大小相同。

当您使用 [][]时，实际上是在创建一个数组数组。这意味着每个数组的大小可以不同。例如:

int[][] jaggedArray = new int[5][]
for(int index = 0; index < jaggedArray.Length ; ++index)
{
jaggedArray[index] = new int[index + 1];
}

内联声明如下所示:

int[,] numbers = { {1, 2}, {3, 4}, {5, 6} };

关于 # 1，请参阅 this SO question

对于锯齿形或多维内联数组，请参见下面的 编程指南:

// Three-dimensional array.
int[, ,] array3D = new int[,,] { { { 1, 2, 3 }, { 4, 5, 6 } },
{ { 7, 8, 9 }, { 10, 11, 12 } } };


// Same array with dimensions specified at declaration.
int[, ,] array3Da = new int[2, 2, 3] { { { 1, 2, 3 }, { 4, 5, 6 } },
{ { 7, 8, 9 }, { 10, 11, 12 } } };

您不必指定维度(array3D) ，但是如果您知道它们永远不会改变，那么了解您正在使用的维度(array3Da)会很有帮助。

您需要了解数组的内部工作原理 除了将双索引转换为单索引外，多维数组充当单维数组。

C # 中的锯齿数组是一个依次为数组的对象数组。

广告3)要初始化像 [][,][,]这样的怪物，你可以这样做:

        int [,][,] multiArr1 = { { new int[,] { { 2, 2 }, { 1, 1 } },
new int[,] { { 2, 2 }, { 1, 1 } } },
{ new int[,] { { 2, 2 }, { 1, 1 } },
new int[,] { { 2, 2 }, { 1, 1 } } } };
int [,][,] multiArr2 = { { new int[,] { { 2, 2 }, { 1, 1 } },
new int[,] { { 2, 2 }, { 1, 1 } } },
{ new int[,] { { 2, 2 }, { 1, 1 } },
new int[,] { { 2, 2 }, { 1, 1 } } } };


int [][,][,] superMultiArray = { multiArr1, multiArr2 };

我认为 C # 中的2d 参差数组内存分配就像 C + + 和 C 中的2d 数组。 Because 2d jagged arrays have pointer which points to array of pointers that each of this pointers points to an array of elements (for example integer elements); like this code in C++,

int** 2DArr {new int* [number1]};
for (int i = 0; i < number1; i++)
{
2DArr[i] = new int[number2];
}

下面代码的内存分配与 C # 中的2d 锯齿数组相同。但是我对此表示怀疑，如果我想错了，你能解释得更详细一些吗。

这篇文章有些年头了，但是下面是我的一些想法。

锯齿数组是多维数组。多维数组有两种类型: 矩形和锯齿形。矩形数组表示 n 维内存块，锯齿数组是数组的数组。

矩形阵列

矩形数组使用逗号声明以分隔每个维度。下面的语句声明了一个矩形二维数组，其维数为3 × 3:

int[,] matrix = new int [3, 3];

参差不齐的数组

Jagged arrays are declared using successive square brackets to represent each dimension. Here is an example of declaring a jagged two-dimensional array, where the outermost dimension is 3:

int[][] matrix = new int[3][];

对于多维数组，可以考虑框或矩形。每行的长度相同，每列的长度相同。

在锯齿数组中，行和列的大小可能不相同。例如，列或行的大小可能不同。这将导致一个形状，可能不是一个直线下来的两侧像一个矩形。相反，两侧可能是 参差不齐。

现在我在这个例子中使用了2维/2数组，但是这适用于更多的情况。

 public class ArrayExamples
{
//Multi-Dimensional Array are of 2 types
//1. Jagged Array: Array of Arrays
//2. rectangular Array: Array having more than one dimension
public void JaggedArray()
{
//Declaring an array with 3 element. Each element containing single dimension array.
//Benefit: Each single dimension array defined can be of different length.
int[][] jaggedArray = new int[3][];
    

jaggedArray[0] = new int[] { 1, 2, 3, 4, 5 };//single dimension array lengh:5
jaggedArray[1] = new int[] { 6,7,8};//single dimension array lengh:3
jaggedArray[2] = new int[] { 9, 10 };//single dimension array lengh:2
    

foreach (var array in jaggedArray)
foreach (var element in array)
{
Console.WriteLine(element);
}
}
    

    

public void RectangularArray()
{
//Declaring a 2 dimensional array with  5 rows and 2 columns.
//Benefits: When we want to declare an array with multiple dimension
//and we know the length as length should be predefined.
//
    

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

    

//This loop will go through all the elements
//This will display all the elements i.e. 1,2,3,4,5,6,7,8,9,10
foreach (var element in array2Dimensional)
{
//Console.WriteLine(element);
}
    

//Accessing specific element in the 2 dimensional array.
//i.e. will display 1 which is the first element of first row and first column.
Console.WriteLine(array2Dimensional[0, 0]);
}
}

多维数组是 C # 中的矩形数组。它在每个维度中只能有固定数量的元素。下面的代码示例向我们展示了如何在 C # 中声明一个多维数组。

int[,] multiArray = new[3,3]

A jagged array is an array of arrays in C#. It can constitute arrays of different sizes in it. The following code example shows us how we can declare a jagged array in C#.

int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int [1];
jaggedArray[1] = new int[2];
jaggedArray[2] = new int[3];

在上面的代码中，我们创建了大小为3的 jaggedArray，这意味着 jaggedArray 是一个由3个数组组成的数组。这3个数组位于 jaggedArray 的索引0、1和2处。从示例中可以清楚地看出，所有这些数组的大小都不同。

锯齿数组应该比传统的多维数组更受欢迎，因为它们在 C # 中具有灵活性。例如，如果我们必须存储一个人的爱好，首选的方法是使用一个参差不齐的数组，因为不是每个人都有相同数量的爱好。兴趣爱好和其他许多事情也是如此。