WALT: In this unit you will learn how to use one-dimensional arrays in Java. You should be familiar with 1D arrays from Python and arrays in Java work in a similar fashion.

Just to recap: arrays are data structures that can, unlike primitive variables, hold more than piece of data at once - so for instance an array (set) of integers, doubles, booleans, or even Strings and other types of objects. In some programming languages, such as Scratch and App Creator, arrays are called lists.

Unit 6 Table of Contents:

Why use arrays?

To represent multiple pieces of related data in one variable (such as exam scores, student names, account numbers, etc.)

Array size

The array size must be set when creating the array - it cannot be modified later on. A block of memory is then reserved for the array.

Data types arrays can store

All primitives as well as object references (not objects themselves)

Creating an array

Take a look at the following example:

int[] testScores = new int[5];

In this line of code we created an array of integers that has size 5 (i.e. it can hold up to 5 integers). Alternatively, you can first declare an array and then initialize it:

Does the keyword "new" look familiar? You have used it to call the constructor to initialize an object of some class - such as Student s1 = new Student("Peter Smith");.

When you compare the array creation and initialization example with the Student object example, you can tell they are very similar. With arrays, the class name is the data type desired followed by []. The only difference is that the constructor takes in the parameter inside the square brackets instead of round brackets, like it is with other classes.

By now, you can probably tell that arrays in Java are special kinds of objects.

The general formula for array declaration and initialization would be as follows:

dataType[] arrayName = new dataType[size];

Default array initialization values

When initializing an array using the new keyword, the following values are used as defaults:

• int: 0
• double: 0.0
• boolean: false
• reference type (any object, including strings): null (no objects are created and thus there is no reference to the object)

Example:

The following line of code will create an array with the following default values:

Initializer lists

An alternative way to declare and initialize an array with specific (not the default) data is by using the so called initializer list. See the example below:

This will cause the following in the memory:

Notice that in the first example, the array slots do not hold the actual text but only references to String objects that hold the actual text. The individual String objects are created and loaded with the corresponding data when using an initializer list.

Array Length

The length of an array (i.e. how many items of data it can hold) is its instance variable (a public final int ) that can be read as follows: arrayName.length

Using the programmers array example above, the following line of code would display 3.

System.out.println(programmers.length));

This property is particularly useful when trying to traverse an array.

Accessing and modifying array elements

To read or modify array items we use the so called index number (see the tables above) which is inside the square brackets. Notice that index numbers always start from zero, not one. For instance, in order to display the fifth score (80) from the scores[] array above, I'd use the following code:

System.out.println(scores[4]);

A common mistake is when you forget to count from 0, not 1 - in our example you'd, for instance, write scores[5] to access the 5th element in the array. This would cause an ArrayIndexOutOfBoundsException being thrown as it would try to read the 6th element of the array which doesn't exist. Index numbers must always be between 0 and one less than the number of elements in the array (arrayName.length-1). So for the scores[] array, the index number must be between 0 and 4 as the array length is 5.

You can modify array elements using index numbers as well. Examples:

To display the last item in an array (regardless of its length), I'd use the following code:

arrayName[arrayName.length-1];

So, the code below will display "Anthony":

System.out.println(programmers[programmers-1]);

As you can see, we have been using a variable as an index — you can do this as long the variable data type is an int.

• Traversing an array happens when you go through all elements of the array, one by one, typically by using a for-loop or a while-loop.
• When using the regular for-loop or a while loop, you must access the individual values by using the index number (which is always an integer).
• Remember that indices for arrays start from zero, not from one. If you forget about this, it can result in an ArrayIndexOutOfBoundsException being thrown.
• Running through an array from the beginning to the end, one element at a time is considered to be linear search (traversing the array in a linear fashion).

Traversing an array using a for-loop

The following example demonstrates how to traverse and print all elements of an array using the for-loop iterator variable as index number:

Passing an array as an argument

A method can receive an array as an argument. Consider the following method that takes in an array of Strings and prints each array value on a separate page alongside its index number:

You must remember that when passing an array as an argument - you are accessing the array directly , so if you are modifying any values in the array inside the method, it indeed gets saved in the original array that was passed as an argument (as what is really passed on is the reference to the original array object, not a copy of the individual values in the array). This is different from passing primitives as parameters where a copy of the original variable is made, thus making changes to these in the method does not affect the value of the original variables.

Traversing an array in reverse

This can be done easily by modifying the for-loop header. An example (a modification of one of the previous examples) follows:

Using the break statement when traversing arrays

Sometimes, you don't need to iterate through the entire array — for instance when looking for the location of a specific value within an array. You can do so by using the return keyword once you have already found what you were looking for and traversing further through the array would be just a waste of resources.

An example of the use of return inside a for-loop traversing an array follows. The returnIndex() method takes in two parameters - an array as well as a string to look up within the array values. It returns an integer — the index number of the array slot where the value is located (and by doing so breaks the loop and exits the method — see line 6). If it has finished traversing through the array and hasn't found what it was looking for, it will use the default return statement — (see line 8) which returns -1.

Looping through a part of an array

You can limit the looping through an array to any range between 0 and the length of the array -1. It's done by adjusting the for-loop header. An example: say you'd like to print only the first five names from the names array. In case there are less than five student names in the array, it will print them all and stop traversing in order not to generate an ArrayOutOfBoundsException:

In the program above I used the AND boolean operator (&&) to combine two logical tests to determine when to finish the execution of the loop:

• i needs to be lower than 5

AND

• i needs to be lower than the length of the loop (this in case my array length is less than 5, so I don't get out of bounds of the array)

An enhanced for-loop is a special type of for-loop that can only be used with arrays, arrayLists as well as some other data structures that fall under the so called Collections (not within the scope of AP CS A).

For-each loops are used only for reading, not modifying array elements.

Syntax:

for (dataType variableName : arrayName)

   {

     commands_to_repeat; // accessing the current array element through the variableName variable

   }

An example of printing all array elements:

We can call this type of for-loop as a for-each loop as in pseudocode you could say:

• "For each item in the array do the following:"

Algorithm types - reading arrays

For your AP exam, you need to be familiar with the following algorithms utilizing arrays and traversals:

• determining the minimum/maximum value in a data set (array) (MIN, MAX functions in Excel)
• calculating the sum, average, and mode of a data set (the mode being the most complex to implement) (SUM,AVERAGE,MODE functions in Excel)
• telling whether at least one value in the data set has a certain property (for instance, it equals some string)
• telling whether all data elements in an array meet a certain condition (e.g. they are all greater than 0)
• reading consecutive pairs of data (reading the value preceding and/or following a certain value in the array)
• telling whether there are or aren't any duplicates in an array
• count the number of elements that meet certain criteria (analogy for COUNTIF in Excel)

Algorithm types - modifying arrays

For your AP exam, you need to be familiar with the following algorithms utilizing traversals for modifying arrays:

• shifting or rotating elements to the left or right
• reversing the order of the elements in the array

Solutions to the algorithm problems

My solutions to the Runestone 6.4 FRQ activities: