This is another extremely exciting lesson, because we’ll learn how to work with even more data. We’ll break free from our linear shackles into full multi-dimensional splendor. Let’s get started!
But first, let’s get a bit more debugging practice!
Write a function called
It should take a
String containing a phone number in the format
111-222-3333 and return it reformatted as
You will want to explore the various
to help you with this task.
In particular, you may find
There are solutions that use
split, others that use
substring, and probably others that use neither!
So far we’ve worked with single data values, arrays of values, and
Strings—which on some level or just character arrays with features.
But all of the plural data that we’ve worked with so far has been linear.
We’ve learned how to put things in order.
But just try linearizing this guy:
It turns out that a lot of the data around us is multidimensional. Photos are just one example.
Of course Java has a way to work with multidimensional data. And, in many ways, it’s a straightforward extension of what we’ve already seen.
Here’s our first multidimensional array:
The syntax is similar to what we saw with single-dimensional arrays.
But instead of a single
 in the variable declaration, we have two, indicating a two-dimensional array.
How would we do three?
Same idea. Also note that on the right side of the initial assignment we can specify sizes for each of the dimensions. The 3-d array shown above has size 8 in the first dimension, 88 in the second dimension, and 8 in the third dimension.
Array indexing in multidimensional arrays works just the same as we’ve seen in the past:
And we can still have problems with our bounds if we’re not careful:
A bi-yearly rant. Forget about rows and columns. Do you want to work with spreadsheets your entire life? This limited mental model will utterly fail you when you need it most!
Let’s explore how multidimensional arrays in Java actually work. Specifically, we’ll talk about why something like this works:
Note one important consequence of the fact that Java arrays are arrays of arrays.
They do not need to be rectangular!
Specifically, an inner array can have a different size at each index.
Some may even be
Let’s look at how.
If this doesn’t make perfect sense to you, don’t worry. Next we’ll show you patterns that you can use below to work with any array, rectangular or non.
These exist, but they are awful. We’ll never do this to you:
Declare and implement a function called
arraySum that receives a two-dimensional array of
double values as its only parameter and returns the sum of the values in the array as a
If the array is
null you should return 0. None of the inner arrays will be
Just like single-dimensional arrays, we can develop similar programming patterns for working with multidimensional arrays. Let’s look at an example together.
Write a method
maxSubarraySum that, given a non-rectangular two-dimensional
int array, returns the sum of the
subarray that sums to the largest value.
So given the following array, with each subarray on a separate line:
1, 2, 4 4, 1, -1 6, 8, -10, -9 -1
You would return 7.
assert that the passed array is not
However, if the passed array is not
null it will contain no empty subarrays.
One hint for this problem is that you may need both an
int variable to store the max and a
to record whether the maximum value has been initialized.
Once you have summed each subarray, check whether either your
boolean value is
false or the sum is larger than
the largest you've seen so far.
After you check the sum of the first subarray, set your
boolean value to
Another approach is to use the counter that you use to proceed through each subarray to determine whether you have
initialized the max value.
Need more practice? Head over to the practice page.