Introduction to Arrays

[comp1110-71]
  • Fabian Muehlboeck

Definition 1. Arrays

[comp1110-15]
  • Liam O'Connor

Arrays are a primary way to store linear, ordered collections of data. The elements of an array must all have the same type. An array type is written by appending [] to the type of the array elements. For example, the type of an array of int values is written as int[], whereas the type of an array of String values is written String[]. We create an array with the new keyword, like so:

int[] arr = new int[50];

The above code makes space in memory (called allocating) for a sequence of 50 int values, and stores the location of that space in memory in the newly-created variable arr.

By default, all ints in our array will be set to zero. If we wish to initialise our array with other values, we can include them in the new invocation like so:

// size no longer needed as javac will count the elements int[] arr = new int[]{10,100,-2,8,0};

We can access the contents of an array by index. The ith element of the array a (starting counting at zero) can be retreived using the notation a[i], for example:

int first = arr[0]; IO.println(first + " is the first (index 0) element!");

We can also update elements of an array using this notation:

arr[0] = first + 1; IO.println("The first element is now: " + arr[0]); // prints 11

To get the length of an array a, we can write a.length:

int len = arr.length; IO.println("The array arr has " + len + " elements.");

Warning. 

  • Liam O'Connor

For Strings, we write str.length() (i.e. calling a method, with the parentheses), but for arrays, we just write arr.length.

Example 2. Printing Array Elements (In reverse order)

[comp1110-72]
  • Fabian Muehlboeck

In the lecture, we went through the following example of looping through an array. Note that, in contrast to earlier, we start our counter variable at the end (i = arr.length), and reduce it before we use it in the body of the loop.

void main() { int x = 6; int[] arr = new int[]{5, 93, -2, 0, 1000000, -1}; int y = arr[0]; int i = arr.length; while(i != 0) { // INV: all elements of arr[i..arr.length-1] have been printed i = i - 1; IO.println(arr[i]); } // i == 0 // INV: all elements of arr[0..arr.length-1] have been printed // all elements of arr have been printed }

It is always a good idea to sanity-check your indices to prevent off-by-one errors (which would crash your program). Often, it suffices to look at the first and last index values.

In this case, i starts as arr.length, but the first valid index from the back is arr.length - 1. Since we assign i to be i - 1 before looking at the array, that works out fine.

For the last index, the loop will end when i == 0, so the last time it could run is when i == 1. In that case, because we again reduce i before accessing the array, the last index we will look at is 0, which is both a valid index if the array is not empty (in which case, we would not be in the loop to begin with), and also the last index we want to look at.

Finally, the loop invariant (§ [comp1110-0W]) tracks the property that we wanted, which is that all elements of the array within a certain range have been printed, in such a way that the range coincides with the full array at the end of the loop.

Example 3. Searching for an Element in an Array, Generally

[comp1110-16]
  • Liam O'Connor, Fabian Muehlboeck
 boolean contains(int[] haystack, int needle) { int i = 0; while(i < haystack.length) { // i <= haystack.length && forall 0 <= j < i, haystack[j] != needle if(needle == haystack[i]) { return true; } i = i + 1; } // i == haystack.length // forall 0 <= j < haystack.length, haystack[j] != needle return false; }

Construction 4. import declarations

[comp1110-75]
  • Fabian Muehlboeck

Writing a program that does something new and amazing is great! But even in that best-case scenario, you will usually need your program to execute many little steps that are very common.

The most common of those are part of the core of your programming language, like numbers, Strings, and basic arithmetic operations. Other common things are often contained in a Standard Library, usually part of a standard language distribution, as in the case of the Java Development Kit (JDK) which you installed as part of our standard software setup. Finally, other people and organizations may publish their own libraries of code that you may be able to include in your own program.

Java's import declaration lets you "import" a library (or parts of it) so you can use its functionality in your code. You typically put them at the top of any code file that uses them. For example, to import the array-related part of the java.util library, you would write:

import java.util.Arrays;

You can also import everything in a particular library using * as the last part of your imported library path, as in:

import java.util.*;

This may look convenient, but can easily cause name clashes and other maintenance issues, and as such is usually not a good idea.

Note 5. Array Equality

[comp1110-73]
  • Fabian Muehlboeck

We've seen earlier that String Equality requires special attention compared to the more common equality operator ==. This is because the operator == expresses sameness, either of a numerical value, or of something larger within computer memory. Sameness implies equality, but not necessarily the other way around. We will look at the technical reasons for this later in the course.

Similar to Strings, Arrays are also larger things in computer memory. But in contrast to Strings, the contents of arrays can change. What that means is that if your idea of equality is that two arrays contain equal values in the same order, then that may be true at one point in your program, and false at a different point, as the contents of one or both of the arrays may change in the meantime. This means that the identity of each array matters a lot more than it does for Strings.

For that reason, a.equals(b) on arrays is the same as a == b. However, the Java Standard Libraries contain a number of standard functions dealing with arrays, among them a suitable equality function. To use it, you need to add an import declaration for java.util.Arrays to the top of your file. You can then use the expression Arrays.equals(a,b) to compare two arrays for equality based on the equality of their elements.

Example 6. Arrays.equals

[comp1110-74]
  • Fabian Muehlboeck
 import java.util.Arrays; void main() { int[] a1 = new int[]{1,2,3,4}; int[] a2 = new int[]{1,2,3,4}; IO.println(a1 == a2); // not the same, hence false IO.println(a1.equals(a2)); // not the same, hence false // contain equal elements, hence true IO.println(Arrays.equals(a1,a2)); a1[0] = 5; // do not contain equal elements, hence false IO.println(Arrays.equals(a1,a2)); int[] a3 = a2; // a3 is now the same as a2 IO.println(a2 == a3); // the same, hence true // the same, hence contain equal elements, hence true IO.println(Arrays.equals(a2,a3)); a2[0] = 10; // this modification affects both a2 and a3 // still the same, hence still contain equal elements, hence true IO.println(Arrays.equals(a2,a3)); }

Construction 7. Command Line Parameters

[comp1110-1L]
  • Liam O'Connor, Fabian Muehlboeck

When we invoke our program, we can pass it command line arguments:

$ java MyProgram argument anotherArgument "this is a multi-word parameter"

If we add a parameter to our main function that has type String[], that array will contain each of those arguments:

void main(String[] args) { int i = 0; while(i < args.length) { IO.println(args[i]); i = i + 1; } }

When called as above, the above program will print the arguments in order, each on one line:

$ java MyProgram argument anotherArgument "this is a multi-word parameter" argument anotherArgument this is a multi-word parameter

Context

    Lecture. Arrays, Specs, Testing, and Searching, Part 1

    [comp1110-2026s2-lec02a]
    • August 4, 2026
    • Fabian Muehlboeck

    Finishing the Password Checker

    [comp1110-70]
    • Fabian Muehlboeck

    Definition. The char type

    [comp1110-0V]
    • Liam O'Connor

    The type char (characters) is for single symbols (a letter, a number, a newline, etc.). Strings are sequences of characters. In Java, we write characters with single-quotes, unlike Strings which require double-quotes. For example, the first character of the string "Hello" is 'H'. To get the nth character of a string, use the method charAt(), for example: "Hello".charAt(0) == 'H'.

    Characters themselves are just numbers, where each symbol has a number according to this ASCII table (the story is more complicated for non-English characters, but this suffices for now). In particular, note that the digit character '4' and the number 4 are very different numbers, however the digits occur consecutively in the ASCII table, so we can convert digit characters to their associated number by subtracting the digit '0', that is: '4' - '0' == 4.

    The module class Character includes a variety of useful functions for working with char, including Character.isLetterOrDigit() and Character.isDigit().

    Loop invariants

    [comp1110-0W]
    • Liam O'Connor, Fabian Muehlboeck

    A loop invariant is a property that must be true of your variables at the start and end of each iteration of a loop. It typically takes the form of an equation or logical formula that relates the values of your variables together. They're not part of the programming language, but I will often write them down in a comment.

    When I speak of the loop invariant for a particular loop, I'm looking for a loop invariant that describes the variables with enough detail to be useful to show that my function is correct.

    When writing a loop, it is often helpful to figure out what the loop invariant is, as this will help you to convince yourself (and others) that the code you wrote is correct.

    For example, the loop invariant for Example [comp1110-0U] is that pos <= pwd.length() and that every character at an odd position in pwd[0..pos-1] is uppercase. Here pwd[0..pos-1] refers to a substring of pwd, including the — it is not valid Java, but just notation for me to write a loop invariant.

    This is true initially, as pos is zero and pwd[0..-1] is the empty string. Furthermore, it is true before and after each iteration, as we increase pos by 2 only after checking that pwd[pos] is uppercase.

    Finally, when the loop terminates not via the early return, that means that the loop guard must be false, i.e pos >= pwd.length(). Combined with our invariant that pos <= pwd.length(), we can conclude that pos == pwd.length() when the loop finishes. This means that, when the loop finishes, the other part of our invariant 'every character at an odd position in pwd[0..pos-1] is uppercase' refers to pwd[0..pwd.length()-1] which is just pwd. Thus, we can use loop invariants to show that our function computes the result it's supposed to.

    Example.  smileyOK

    [comp1110-0X]
    • Liam O'Connor, Fabian Muehlboeck

    To implement the check that the emoji "O_O" (we called this "smiley" because the original proposal was for a smiley-face, but that turned out to conflict with the uppercase constraint) is present for Example [comp1110-0O], we must once again loop through each character in the password. However, seeing as the emoji "O_O" is three characters long, we can exit the loop as soon as we reach pwd.length() - 2, as it would be impossible to see the emoji "O_O" in a string of length less than 3. If we find the word, we immediately exit the loop and return true.

    boolean smileyOK(String pwd) { int i = 0; while (i < pwd.length() - 2) { // INV: O_O not in pwd[0..i+1] char ith = pwd.charAt(i); char ipoth = pwd.charAt(i+1); char iptth = pwd.charAt(i+2); if(ith == 'O' && ipoth == '_' && iptth == 'O') { return true; } i = i + 1; } // i >= pwd.length() - 2 // O_O not in pwd[0..pwd.length()-1] (= pwd) return false; }

    I included the important parts of the loop invariant for the above loop. We always know that "O_O" is not the parts of pwd up to the next position (because in that case, it would have had to start in the previous position, pos-1). Before the loop runs, i is zero, so there is no position less than i to start from (thereby making the invariant true trivially). For each iteration, we increase i by one only after we check that the emoji "O_O" does not start there, thus maintaining the invariant. Thus, when the loop is over without early return and i == pwd.length() - 2, we can conclude that the emoji "O_O" does not appear anywhere in the string, and therefore return false.

    Warning. 

    • Liam O'Connor, Fabian Muehlboeck

    We should always be careful to test edge cases. Why is it safe to put an empty string "" as input for pwd here?

    Introduction to Arrays

    [comp1110-71]
    • Fabian Muehlboeck

    Definition. Arrays

    [comp1110-15]
    • Liam O'Connor

    Arrays are a primary way to store linear, ordered collections of data. The elements of an array must all have the same type. An array type is written by appending [] to the type of the array elements. For example, the type of an array of int values is written as int[], whereas the type of an array of String values is written String[]. We create an array with the new keyword, like so:

    int[] arr = new int[50];

    The above code makes space in memory (called allocating) for a sequence of 50 int values, and stores the location of that space in memory in the newly-created variable arr.

    By default, all ints in our array will be set to zero. If we wish to initialise our array with other values, we can include them in the new invocation like so:

    // size no longer needed as javac will count the elements int[] arr = new int[]{10,100,-2,8,0};

    We can access the contents of an array by index. The ith element of the array a (starting counting at zero) can be retreived using the notation a[i], for example:

    int first = arr[0]; IO.println(first + " is the first (index 0) element!");

    We can also update elements of an array using this notation:

    arr[0] = first + 1; IO.println("The first element is now: " + arr[0]); // prints 11

    To get the length of an array a, we can write a.length:

    int len = arr.length; IO.println("The array arr has " + len + " elements.");

    Warning. 

    • Liam O'Connor

    For Strings, we write str.length() (i.e. calling a method, with the parentheses), but for arrays, we just write arr.length.

    Example. Printing Array Elements (In reverse order)

    [comp1110-72]
    • Fabian Muehlboeck

    In the lecture, we went through the following example of looping through an array. Note that, in contrast to earlier, we start our counter variable at the end (i = arr.length), and reduce it before we use it in the body of the loop.

    void main() { int x = 6; int[] arr = new int[]{5, 93, -2, 0, 1000000, -1}; int y = arr[0]; int i = arr.length; while(i != 0) { // INV: all elements of arr[i..arr.length-1] have been printed i = i - 1; IO.println(arr[i]); } // i == 0 // INV: all elements of arr[0..arr.length-1] have been printed // all elements of arr have been printed }

    It is always a good idea to sanity-check your indices to prevent off-by-one errors (which would crash your program). Often, it suffices to look at the first and last index values.

    In this case, i starts as arr.length, but the first valid index from the back is arr.length - 1. Since we assign i to be i - 1 before looking at the array, that works out fine.

    For the last index, the loop will end when i == 0, so the last time it could run is when i == 1. In that case, because we again reduce i before accessing the array, the last index we will look at is 0, which is both a valid index if the array is not empty (in which case, we would not be in the loop to begin with), and also the last index we want to look at.

    Finally, the loop invariant (§ [comp1110-0W]) tracks the property that we wanted, which is that all elements of the array within a certain range have been printed, in such a way that the range coincides with the full array at the end of the loop.

    Example. Searching for an Element in an Array, Generally

    [comp1110-16]
    • Liam O'Connor, Fabian Muehlboeck
     boolean contains(int[] haystack, int needle) { int i = 0; while(i < haystack.length) { // i <= haystack.length && forall 0 <= j < i, haystack[j] != needle if(needle == haystack[i]) { return true; } i = i + 1; } // i == haystack.length // forall 0 <= j < haystack.length, haystack[j] != needle return false; }

    Construction. import declarations

    [comp1110-75]
    • Fabian Muehlboeck

    Writing a program that does something new and amazing is great! But even in that best-case scenario, you will usually need your program to execute many little steps that are very common.

    The most common of those are part of the core of your programming language, like numbers, Strings, and basic arithmetic operations. Other common things are often contained in a Standard Library, usually part of a standard language distribution, as in the case of the Java Development Kit (JDK) which you installed as part of our standard software setup. Finally, other people and organizations may publish their own libraries of code that you may be able to include in your own program.

    Java's import declaration lets you "import" a library (or parts of it) so you can use its functionality in your code. You typically put them at the top of any code file that uses them. For example, to import the array-related part of the java.util library, you would write:

    import java.util.Arrays;

    You can also import everything in a particular library using * as the last part of your imported library path, as in:

    import java.util.*;

    This may look convenient, but can easily cause name clashes and other maintenance issues, and as such is usually not a good idea.

    Note. Array Equality

    [comp1110-73]
    • Fabian Muehlboeck

    We've seen earlier that String Equality requires special attention compared to the more common equality operator ==. This is because the operator == expresses sameness, either of a numerical value, or of something larger within computer memory. Sameness implies equality, but not necessarily the other way around. We will look at the technical reasons for this later in the course.

    Similar to Strings, Arrays are also larger things in computer memory. But in contrast to Strings, the contents of arrays can change. What that means is that if your idea of equality is that two arrays contain equal values in the same order, then that may be true at one point in your program, and false at a different point, as the contents of one or both of the arrays may change in the meantime. This means that the identity of each array matters a lot more than it does for Strings.

    For that reason, a.equals(b) on arrays is the same as a == b. However, the Java Standard Libraries contain a number of standard functions dealing with arrays, among them a suitable equality function. To use it, you need to add an import declaration for java.util.Arrays to the top of your file. You can then use the expression Arrays.equals(a,b) to compare two arrays for equality based on the equality of their elements.

    Example. Arrays.equals

    [comp1110-74]
    • Fabian Muehlboeck
     import java.util.Arrays; void main() { int[] a1 = new int[]{1,2,3,4}; int[] a2 = new int[]{1,2,3,4}; IO.println(a1 == a2); // not the same, hence false IO.println(a1.equals(a2)); // not the same, hence false // contain equal elements, hence true IO.println(Arrays.equals(a1,a2)); a1[0] = 5; // do not contain equal elements, hence false IO.println(Arrays.equals(a1,a2)); int[] a3 = a2; // a3 is now the same as a2 IO.println(a2 == a3); // the same, hence true // the same, hence contain equal elements, hence true IO.println(Arrays.equals(a2,a3)); a2[0] = 10; // this modification affects both a2 and a3 // still the same, hence still contain equal elements, hence true IO.println(Arrays.equals(a2,a3)); }

    Construction. Command Line Parameters

    [comp1110-1L]
    • Liam O'Connor, Fabian Muehlboeck

    When we invoke our program, we can pass it command line arguments:

    $ java MyProgram argument anotherArgument "this is a multi-word parameter"

    If we add a parameter to our main function that has type String[], that array will contain each of those arguments:

    void main(String[] args) { int i = 0; while(i < args.length) { IO.println(args[i]); i = i + 1; } }

    When called as above, the above program will print the arguments in order, each on one line:

    $ java MyProgram argument anotherArgument "this is a multi-word parameter" argument anotherArgument this is a multi-word parameter

    Specifications

    [comp1110-17]
    • Liam O'Connor

    What does it mean for software to be correct? Typically there are two components:

    • The software does what it's supposed to.
    • The software doesn't do what it's not supposed to.

    (often programmers acknowledge the former but forget the latter)

    How do we determine what the software is (and is not) supposed to do? This is where specifications come in.

    Definition. Preconditions and Postconditions

    [comp1110-18]
    • Liam O'Connor

    Specifications often take the form of preconditions and postconditions for a function.

    • Preconditions state any assumptions made about inputs or parameters to the function.
    • Postconditions state what the result(s) of a function will be, if successfully executed with inputs that satisfy the preconditions.

    Sometimes these pairings of pre and post-conditions are called the contract for the function. If the caller satisfies the preconditions, the function is "contractually obliged" to satisfy the postconditions.

    Writing Javadoc comments.

    [comp1110-19]
    • Liam O'Connor

    Javadoc is the standard Java documentation tool. Documentation for Java functions (such as we have seen for e.g. the Character class) are produced using this tool.

    In Javadoc, each function is annotated with a special documentation comment, which looks like a typical multi-line comment, except it starts with two asterisks (/**) rather than just one:

    /** A main function */ void main(String[] args) { IO.println("Hello"); }

    We can include special commands in our Javadoc comments which are picked up by the tool and treated specially. Javadoc includes markup specifically for the writing of specifications. We can describe our parameters (and any preconditions associated with them) using the @param markup, and the @return markup to describe our return value (and any postconditions associated with them).

    /** A function to compute the remainder left after dividing. @param numerator number to divide. (pre: >= 0) @param denominator number to divide by. (pre: > 0) @return an integer x with post: x = numerator % denominator */ int remainder(int numerator, int denominator) { int r = numerator; while (r >= denominator) { r = r - denominator; } return r; }

    Example. Adding specs to contains

    [comp1110-1A]
    • Liam O'Connor, Fabian Muehlboeck

    We can take the contains function from Example [comp1110-16] and annotate it with a specification. It holds no assumptions about the input parameters, so the function has no nontrivial preconditions. Its postcondition, however, captures the notion of correctness for this function:

    /** Returns if an integer is contained in an integer array @param haystack is an integer array @param needle is the integer we want to search for @return true iff there exists some j such that haystack[j] == needle */ boolean contains(int[] haystack, int needle) { int i = 0; while(i < haystack.length) { // i <= haystack.length && forall 0 <= j < i, haystack[j] != needle if(needle == haystack[i]) { return true; } i = i + 1; } // i == haystack.length // forall 0 <= j < haystack.length, haystack[j] != needle return false; }

    Note how the loop invariant, allows us to reason that our postcondition (the @return clause above) is satisfied by our function.

    Testing

    [comp1110-1B]
    • Liam O'Connor

    Construction. assertions in Java

    [comp1110-1C]
    • Liam O'Connor

    The assert command in Java looks like this:

    void main() { assert (1 == 2); }

    If you compile and run this program with the -ea (enable assertions) option, it will crash on the assert line and report an assertion violation, because 1 == 2 will evaluate to false.

    $ javac Assert.java $ java Assert # no -ea, nothing happens $ java -ea Assert Exception in thread "main" java.lang.AssertionError at Assert.main(Assert.java:2)

    If you give an assert an expression that evaluates to true, the program will continue executing as normal.

    You can use assertions to check that your preconditions are satisfied in a function — it's better to crash and stop the program if the environment doesn't match your expectation than continue to run and potentially do something wrong.

    Warning. 

    • Liam O'Connor
    Always remember to run your program with the -ea option, or you might be fooled into thinking your preconditions hold when they do not!

    For the first part of this course, we will use assert for testing.

    Warning. A word from E.W. Dijsktra

    [comp1110-1D]
    • Liam O'Connor

    Program testing can be used to show the presence of bugs, but never to show their absence!

    Whenever you run a test, that is one possible execution out of potentially millions, or even infinite. Try to be thorough with your testing, but be aware of its limitations!

    Example. Testing contains with assert

    [comp1110-1E]
    • Liam O'Connor, Fabian Muehlboeck

    Take the contains function again from Example [comp1110-1A] and Example [comp1110-16]. Let us test it using assert:

    void main() { int[] a1 = new int[]{1,2,3,4,5}; assert (contains(a1, 0) == false); assert (contains(a1,5)); assert (contains(a1,3)); int[] a2 = new int[]{-2, 0, 1000000}; assert (contains(a2, -2)); assert (!contains(a2,5)); }

    Try to make each of these tests fail by modifying only the function contains.

    bars magnifying-glass caret-down plus minus arrow-right xmark