CSharp/C# Tutorial - C# Multidimensional Arrays

• « Previous
• Next »

Multidimensional arrays come in two varieties: rectangular and jagged.

Rectangular arrays represent an n-dimensional block of memory, and jagged arrays are arrays of arrays.

Rectangular arrays

Rectangular arrays are declared using commas to separate each dimension.

The following declares a rectangular two-dimensional array, where the dimensions are 3 by 3:

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

The GetLength method of an array returns the length for a given dimension starting at 0:

for (int i = 0; i < matrix.GetLength(0); i++) {
    for (int j = 0; j < matrix.GetLength(1); j++) {
        matrix[i,j] = i * 3 + j; 
    }
}

A rectangular array can be initialized as follows:

int[,] matrix = new int[,] { 
                        {0,1,2}, 
                        {3,4,5}, 
                        {6,7,8} 
                        }; 

Jagged arrays

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][]; 

The inner dimensions aren't specified in the declaration, each inner array can be an arbitrary length.

Each inner array is implicitly initialized to null rather than an empty array.

Each inner array must be created manually:

for (int i = 0; i < matrix.Length; i++) { 
    matrix[i] = new int[3]; // Create inner array 
    for (int j = 0; j < matrix[i].Length; j++)
        matrix[i][j] = i * 3 + j; 
    } 
}

A jagged array can be initialized as follows:

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

Array Initialization

There are two ways to shorten array initialization expressions.

The first is to omit the new operator and type qualifications:

char[] vowels = {'a','e','i','o','u'}; 
int[,] rectangularMatrix = { 
    {0,1,2}, /*from   w  w w  .  j  a  v  a 2  s.co  m*/
    {3,4,5}, 
    {6,7,8} 
}; 

int[][] jaggedMatrix = { 
    new int[] {0,1,2}, 
    new int[] {3,4,5,2,2,2,2}, 
    new int[] {6,7,8} 
}; 

The second approach is to use the var keyword, which tells the compiler to implicitly type a local variable:

var i = 3; // i is implicitly of type int 
var s = "asdf"; // s is implicitly of type string 
/* w  w w .jav a 2  s  .c  om*/
var rectMatrix = new int[,]{ 
    {0,1,2}, 
    {3,4,5}, 
    {6,7,8} 
}; 

var jaggedMatrix = new int[][]{
     new int[] {0,1,2},
     new int[] {3,4,5},
     new int[] {6,7,8} 
}; 

We can omit the type qualifier after the new keyword and have the compiler infer the array type:

var letters = new[] {'a','e','i','o','u'}; // Compiler infers char[]

• Next »
• « Previous