In C# there are 2 ways to create mutlidimensional arrays.
int[,] array1 = new int[32,32];int[][] array2 = new int[32][];for(int i=0;i<32;i++) array2[i] = new int[32];I know that the first method creates a 1-dimensional array internally, and that the second method creates an array of arrays (slower access).
However in Java, there is no such thing as [,], and I see multidimensional arrays declared like this:
int[][] array3 = new int[32][32];Since such syntax is illegal in C#, and Java has no int[,], I'm wondering if this is equivilant to array1? Or is it still an array of arrays?
Best Answer
It's still an array of arrays. It's just that in C# you'd have to create each subarray in a loop. So this Java:
// Javaint[][] array3 = new int[32][32];is equivalent to this C#:
// C#int[][] array3 = new int[32][];for (int i = 0; i < array3.Length; i++){array3[i] = new int[32];}(As Slaks says, jagged arrays are generally faster in .NET than rectangular arrays. They're less efficient in terms of memory though.)
You are incorrect; jagged (nested) arrays are faster. (the CLR is optimized for them)
Java does not support true multi-dimensional arrays; that's a jagged array.
The Java syntax automatically creates all of the inner arrays; in C#, that would need a separate loop.
Because people were concerned about the performance of multi-dimension vs staggered arrays in .NET, I implemented a few tests and benchmarked the results on 8k by 8k elements:
The tests were:
- Multi-dimensional 2D array
- Multi-dimensional with indices backwards (y first)
- Multi-dimensional with GetLength(x) instead of integer bound
- Staggered with backwards indicies
- Staggered
- One dimensional (size x size) with multiplication in index
- One dimensional with increment index
And the results:
one <> Elapsed Time: 0.543558stwo <> Elapsed Time: 0.8911516sthree <> Elapsed Time: 0.8908123sfour <> Elapsed Time: 1.1367238sfive <> Elapsed Time: 0.3039648ssix <> Elapsed Time: 0.8110969sseven <> Elapsed Time: 0.2629394sFor fun I ran them on the WP7 emulator as well, and got similar numbers.
Code of the test function is here.
In Java you are declaring an array of arrays.
You can see this by the following code:
int[][] arrOfArr = new int[5][];arrOfArr[0] = new int[5];arrOfArr[1] = new int[1];arrOfArr[2] = new int[9];...int[][] arr = new int[3][3]; is just shorthand for:
int[][] arr = new int[3][];arr[0] = new int[3];arr[1] = new int[3];arr[2] = new int[3];I was translating some Java code to C# - here is how I did the Jagged array
//Javaprivate static int grad3[][] = {{1,1,0},{-1,1,0},{1,-1,0},{-1,-1,0},{1,0,1},{-1,0,1},{1,0,-1},{-1,0,-1},{0,1,1},{0,-1,1},{0,1,-1},{0,-1,-1}};//C#private static int[,] grad3setup = { { 1, 1, 0 }, { -1, 1, 0 }, { 1, -1, 0 }, { -1, -1, 0 }, { 1, 0, 1 }, { -1, 0, 1 }, { 1, 0, -1 }, { -1, 0, -1 }, { 0, 1, 1 }, { 0, -1, 1 }, { 0, 1, -1 }, { 0, -1, -1 } };private static int[][] grad3{get{int[][] grad3 = new int[12][];for (int i = 0; i < grad3.Length; i++){grad3[i] = new int[3] { grad3setup[i, 0], grad3setup[i, 1], grad3setup[i, 2] };}return grad3;}}It is an array of arrays with the same performance tradeoffs as in C#.If you know that your array of arrays is not going to be jagged, then you can wrap it in a class to get 2-d indexing on a 1-d backing array.