Java’s Built-In Lists

Lists are built into Java. There are several variations of them. We will mostly use the LinkedList class in this course. Since you know lists conceptually, we’ll do this introduction largely through examples.

1 Overview of Lists

Recall that our last set of notes showed you three versions of a checkOut method on Books:

This set of examples is very helpful in setting up lists in Java for those of you coming from cs1101/1102. Why? In Racket, lists behaved as in Version 1. In Java, lists behave as in Version 3.

2 Creating Lists in Java: the LinkedList class

To keep things simple, we’ll start with just lists of strings, rather than lists of Books.

First, let’s create an empty linked list of strings, called Words:

The <String> tells Java what type of data will go into the list. Since lists could contain any kind of data, Java needs to know what type of data is in any particular list to help it check types at compile time. If instead we wanted a list of numbers (say containing the points earned on each question in a quiz), we would write

2.1 Integer versus int

Notice that we used <Integer> instead of <int> (as this course has used all along for numbers). The type given to a LinkedList must be the name of either a class or an interface. In Java, Integer is a class that holds a number, whereas int is just a number by itself (without a class). Operations on ints are faster than the corresponding ones on Integer (since there is no class involved), but if you need to treat a number as a class, you must use Integer instead.

2.2 Importing LinkedList

We have to tell Java whenever your code uses its built-in classes (beyond simple kinds of data like String). You’ve already experience the idea of import when you set up JUnit. Similarly, to use LinkedList class, we have to import the class definition into our program. So a complete file with our two list definitions would look like:

Naturally, you can use LinkedList inside more than just the Examples class (we will do so shortly); we’re putting the lists in the Examples class here to give a simple way to play with the lists for now.

3 Operations on Lists: Adding and Counting Elements

The methods for adding elements to the front of a list and getting the length of a list are called addFirst and size, respectively. Here’s an example of of them, written as a series of interactions in DrJava.

If you instead wanted the final list to have pie first and corn second (ie, adding puts new elements on the end of the list), you would use the add method instead of addFirst. We’re using addFirst today as it matches the behavior of cons from Racket.

This sequence of statements shows that the list methods in Java modify the original list (which was not true in Racket–cons left the original list intact, and made it the programmer’s responsibility to save the new list). Once you add an element to a list in Java, you no longer have access to the list without the element. There is no analog to the Racket rest operator, because the previous list no longer exists.

[Side note: If you want to see the full list of operators provided on LinkedLists, check out the official LinkedList documentation.]

What does the sequence above suggest is the return type of the addFirst method? Nothing prints, so it seems to return void. Try the following interaction:

Java raises an error that "No method in void has name ’addFirst’". In Java, addFirst does indeed return void, so you cannot chain together expressions as you might have been used to in Racket.

Both of these traits of addFirst—modifying the original list and returning void—have interesting implications for how we program. We will discuss these issues as they come up throughout the course. For now, the implication is that you can’t create lists using the same pattern as you did if you are coming from Racket.

4 Creating Lists and Testing With Them

So far, we created lists interactively at the prompt. How and where should you create lists in an actual Java program?

We’ve seen that you have to create lists through a sequence of separate calls to addFirst, such as:

The question is where to put these lines. Java requires these to be inside a method. They cannot lie in a class without being in a method. Specifically, you CANNOT do the following:

So which methods can you put these lines in? You have three options:

• Inside the Examples class constructor

• Inside the test method itself (i.e., the one that does AssertEquals)

• Inside a new method that you use to create test data

If you want to use the same list across multiple test cases, creating it in the Examples constructor makes sense – this creates it once, then each test case can refer to the same list.

4.1 Aside: What if A Method Modifies the List During Testing?

But what if you want to test a method that modifies the list. Won’t that method destroy the original list and break other tests? Yes. When you are testing methods that modify lists, you have to reset the list contents before each test.

It turns out that JUnit4 handles this automatically – it will call your Examples constructor before running each @Test, just to guard against this. If you want to be more explicit about recreating the list, you can use another feature of JUnit called a @Before tag, which designates a method to run before each @Test method runs.

Here’s a sample class that shows all three approaches:

5 Iterating Over Java Lists

Let’s write a method to sum up the numbers in a LinkedList of integers.

To process a list in Java, we use something called a for loop. There are two forms of these loops in Java. We’ll show you one today, and another one in a couple of days.

The basic idea of a for loop is that it walks over a list, visiting each element exactly once. Your code maintains whatever history it needs from element to element, and returns that as the answer. Let’s see a concrete example.

What’s going on here? The for loop walks down the list, letting each element from numList be called n exactly once. As the for loop progresses, the history we need to remember is the running sum of the elements. We set up something called a variable to hold the running sum. A variable is a name under which we can store a single value at any time. It can be updated using =. The runningSum is 0 at the start of the computation, and is increased by n each step through the loop. At the end of the loop, the entire sum is in the runningSum, so we return it.

5.1 The General Shape to Process a List

If you like generalization, here is a general shape of a program to process a list in Java. What information the history holds will change from computation to computation, but the shape of the method – initializing the history, updating it the loop, and returning it at the end – is the same from loop to loop.

n the following code skeleton, substitute single expressions for terms in all-caps, and substitute computations for descriptions in square-brackets:

Getting used to these loops just requires a bit of practice.

6 Which Class Do These List Methods Go Into?

Remember the rule of thumb in object-oriented programming: methods go in the class that has their primary data. Here, we are creating the lists in the Examples class, so these methods would also go into the Examples class.

But usually, your lists are a field in some other class. Returning to our Book example, if we created a library, we would define a list of books in the library and put methods inside the Library class:

7 For Those with Prior Java: why LinkedList?

8 Practice Problems Over Lists and For-Loops

Here are two practice problems you can try over lists and for-loops.

• Write a method countLongStrings that takes a list of Strings and counts how many of those Strings are longer than 5 characters. The String class has a length method.

• If you miss the Dillos, write a method reviveAllDillos that takes a list of Dillos and returns a list of new Dillos that have the same lengths as the originals, but are all alive.

Here are the solutions for both problems. Notice how we have filled in the pattern from before: the type of result matches the return type of the function, and the result gets updated by what we do to process each individual Dillo in the list: