Java 2D Array ExamplesUse 2D arrays and jagged arrays. Initialize arrays and assign elements.
2D array. In Java 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. 2D syntax notes. We can access an element from a 2D array using 2 indexes. And looping over a 2D can be done with nested for-loops.
Array
Array example. To understand 2D arrays, we need to review several steps. The syntax for 2D arrays uses 2 values to address an element.
Step 1 We introduce a two-dimensional array of width 4 and height 4—a little square.
Step 2 We assign some elements with the array at indexes (two are required, an X and a Y).
Step 3 Here we loop over the top-level elements in a for-loop—each element itself contains another array.
Step 4 We use the subarrays like a one-dimensional array containing int values. We have an array of equal-length arrays. Java program that uses 2D array
public class Program { public static void main(String[] args) { // Step 1: create 2-dimensional array. int[][] values = new int; // Step 2: assign three elements in it. values = 1; values = 2; values = 3; // Step 3: loop over top-level arrays. for (int i = 0; i < values.length; i++) { // Step 4: 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(); } } }
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); } }
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.
Array
String Arrays
And The first subarray has two elements. The second one has three String elements. We loop over all these values.
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(); } } }
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); } }
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 } }
10 100 1000 0
Benchmark, flat array. Two-dimensional arrays often come with performance losses. The benchmark sets up two 10 by 10 arrays. It then does a load and a store in the arrays.
Version 1 Here we benchmark a flattened array (a 2D array stored as a 1D array).
Version 2 In this version of the code we use a real 2D array, and use 2 indexes to get an element.
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(); // Version 1: 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(); // Version 2: 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); } }
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.
HashMap