To recap: An array is a means for storing multiple values of the same kind. Those kinds can be ints. Those kinds can be Strings. Those kinds can be... other arrays.
The simplest way to think of this is to picture a grid.
int [] [] twoDArray = new int [3][3];
Would generate something akin to this:
| 0 | 1 | 2 | |
|---|---|---|---|
| 0 | |||
| 1 | |||
| 2 |
Each of the empty boxes can hold an int value.
The type of twoDArray[0] is 'int []'.
To process ALL of the cells in this block you'd most likely write a nested set of for loops:
for (int i = 0; i < 3; i ++) {
for (int j = 0; j < 3; j++ ) {
System.out.println(i + ", " + j + ": " + twoDArray [i] [j] );
}
}
Now the grid analogy breaks down just a bit when you make an array more complicated. For instance, each row could have a different number of columns. If you were building a more sophisticated application you would probably not want to hard-code the size of the arrays in your loops, but would be more likely to use:
for (int i = 0; i < twoDArray.length; i++) {
for (int j = 0; j < twoDArray[i].length; j++) {
But the principle is the same.
By way of example, let's make a table of five rows, where each row has one more column than the last. We'll populate each cell with the product of the row and column indexes:
int [] [] twoDArray = new int [5][];
for (int i = 0; i < 5; i ++) {
twoDArray [i] = new int[i+1]; //NOTE THIS! For each row we create a new row of boxes of the correct length.
for (int j = 0; j <= i; j++) {
twoDArray [i] [j] = i*j;
}
}
| 0 | 1 | 2 | 3 | 4 | |
|---|---|---|---|---|---|
| 0 | 0 | ||||
| 1 | 0 | 1 | |||
| 2 | 0 | 2 | 4 | ||
| 3 | 0 | 3 | 6 | 9 | |
| 4 | 0 | 4 | 8 | 12 | 16 |
To print out the contents one could simply write this:
for (int i = 0; i < twoDArray.length ; i ++) {
for (int j = 0; j < twoDArray [i].length ; j++) {
System.out.println(i + ", " + j + ": " + twoDArray [i] [j] );
}
}
Which would generate the following output:
0, 0: 0
1, 0: 0
1, 1: 1
2, 0: 0
2, 1: 2
2, 2: 4
3, 0: 0
3, 1: 3
3, 2: 6
3, 3: 9
4, 0: 0
4, 1: 4
4, 2: 8
4, 3: 12
4, 4: 16
It would certainly possible to put this into a more readable format if one wished, of course.
For instance, if you changed the code to this:
for (int i = 0; i < twoDArray.length ; i ++) {
for (int j = 0; j < twoDArray [i].length ; j++) {
System.out.print( twoDArray [i] [j] );
if (j < (twoDArray [i].length - 1)) {
System.out.print(",");
}
else {
System.out.println();
}
}
}
We've introduced something I haven't used before on this blog. While System.out.println should be familiar, we also have System.out.print. It's basically the same thing, but it doesn't end by creating a new line. This gives us the option to add more text after it. System.out.println() with no arguments just ends the current line of output.
The output from the above would therefore take the following form:
0
0,1
0,2,4
0,3,6,9
0,4,8,12,16
Which closely matches the table up above. Naturally, if the arrays had been created in a more complex manner the output would reflect that.
This concept can be extended to three, four, or 12 dimensions if you so choose. Mind you, it gets mighty hard to visualize past three, Just remember that the content of an array cell can be pretty much anything, including another array.
No comments:
Post a Comment