## Java

Java 2D Array Examples, Jagged Arrays

2D arrays. Not all elements come in linear order, one after another. Some have spatial relationships on a two-dimensional plane, a grid. We use 2D arrays to represent this.

Initializers. The syntax of 2D arrays is often complex. Two integer indexes locate a point in a 2D array. And with initializers, we quickly create these arrays.

Array example. We introduce a two-dimensional array of width 4 and height 4—a little square. I assign some elements with the array at indexes (two are required, an X and a Y).

Loop: In the nested for-loops we iterate over each element. Each row contains a subarray.

And: We use the subarrays like a one-dimensional array containing int values. We have an array of equal-length arrays.

Int
```Based on:

Java 7

Java program that uses 2D array

public class Program {
public static void main(String[] args) {

// Create new 2-dimensional array.
int[][] values = new int;

// Assign three elements within it.
values = 1;
values = 2;
values = 3;

// Loop over top-level arrays.
for (int i = 0; i < values.length; i++) {

// Loop and display sub-arrays.
int[] sub = values[i];
for (int x = 0; x < sub.length; x++) {
System.out.print(sub[x] + " ");
}
System.out.println();
}
}
}

Output

1 0 0 0
0 2 0 0
0 0 0 0
0 0 3 0``` Array initializers. With these, we fill a newly-declared array with constant values. Here I create another little square, this time 2 by 2, with the values one through 4 in it.

Note: This syntax requires just one line. It is easier to type and review for humans.

```Java program that uses 2D array initializer

public class Program {
public static void main(String[] args) {

// Use initialize syntax.
int[][] values = { { 1, 2 }, { 3, 4 } };
System.out.println(values);
System.out.println(values);
System.out.println(values);
System.out.println(values);
}
}

Output

1
3
2
4``` Jagged array. This is like a 2D array but with irregular subarray lengths. Its lengths are not even—they are jagged. Here we create a jagged array of two String arrays.

And: The first subarray has two elements. The second one has three String elements. We loop over all these values.

Strings
```Java program that uses jagged array

public class Program {
public static void main(String[] args) {

// Create an array of String arrays: a jagged array.
String[][] values = new String[];

// Fill first row with 2-element array.
values = new String;
values = "cat";
values = "dog";

// Use 3-element array for second row.
values = new String;
values = "fish";
values = "bird";
values = "lizard";

// Display rows and elements.
for (String[] array : values) {
for (String element : array) {
System.out.print(element);
System.out.print(" ");
}
System.out.println();
}
}
}

Output

cat dog
fish bird lizard``` 3D array. Usually two dimensions is enough, but we can use three dimensions in an array. And even more are supported. It is rare to need a 3D array.

Tip: Three-dimensional arrays can often be replaced with lesser-dimensioned arrays. This would likely be faster.

```Java program that creates 3D array

public class Program {
public static void main(String[] args) {

// Create space cube with 9 points.
byte[][][] space = new byte;
space = 10;
space = 20; // Middle of the cube.
space = 30;

// Display points in our space-cube.
System.out.println(space);
System.out.println(space);
System.out.println(space);
}
}

Output

10
20
30``` Flattened 2D arrays. A compiler transforms a 2D array indexing operation into multiplication and addition. So to a compiler, a 2D array is similar to a 1D array with an indexing function.

Here: I develop a flattened 2D array, which uses a multiply and add to locate elements in a 1D array.

Indexes: We add the X coordinate to the Y coordinate multiplied by the number of rows. Two indexes are combined into one.

```Java program that uses flattened 2D array

public class Program {
public static void main(String[] args) {

// Create 4 by 4 one-dimension array.
// Can access 0, 0 through 3, 3 with multiplication.
int[] array = new int[4 * 4];

// Assign locations in the flattened array.
array[0 + (1 * 4)] = 10; // 0, 1
array[3 + (3 * 4)] = 100; // 3, 3
array[2 + (2 * 4)] = 1000; // 2, 2

// Read those locations.
System.out.println(array[0 + (1 * 4)]);
System.out.println(array[3 + (3 * 4)]);
System.out.println(array[2 + (2 * 4)]);

// Read an empty location.
System.out.println(array[3 + (2 * 4)]); // 3, 2
}
}

Output

10
100
1000
0``` Flat array benchmark. Two-dimensional arrays often come with performance losses. Here I benchmark a flattened array (a 2D array stored as a 1D array) against a real 2D array.

Description: The benchmark sets up two 10 by 10 arrays. It then does a load and a store in the two arrays at two positions.

Result: The program shows the performance advantage of 1D arrays over 2D arrays. A flat array is nearly twice as fast.

```Java program that benchmarks flat, 2D arrays

public class Program {
public static void main(String[] args) {

int[] flat = new int[10 * 10]; // Flattened 10 x 10 array.
flat[0 + (4 * 10)] = 1;

int[][] two = new int; // 10 x 10 two-dimensional array.
two = 1;

long t1 = System.currentTimeMillis();

// ... Read, assign flattened array.
for (int i = 0; i < 100000000; i++) {
int value = flat[0 + (4 * 10)];
flat[9 + (9 * 10)] = value;
}

long t2 = System.currentTimeMillis();

// ... Read, assign 2D array.
for (int i = 0; i < 100000000; i++) {
int value = two;
two = value;
}

long t3 = System.currentTimeMillis();

// ... Times.
System.out.println(t2 - t1);
System.out.println(t3 - t2);
}
}

Output

131 ms,  Flattened 1D array, load and store
256 ms,  2D array, load and store```

Alternatives. We can use alternative data structures to replace a 2D array. A HashMap can store ArrayLists in its keys: we can look up collections by any index value.

HashMapArrayList

A syntax form. 2D arrays use a convenient syntax form for storing data with 2D spatial relationships. We index a 2D array with a pair of coordinates.

Drawbacks. Performance suffers with 2D arrays—using 1D arrays may prove worthwhile. And often programs can be written in a clearer way with simpler collections.