Before you keep reading...

Runestone Academy can only continue if we get support from individuals like you. As a student you are well aware of the high cost of textbooks. Our mission is to provide great books to you for free, but we ask that you consider a $10 donation, more if you can or less if $10 is a burden.

Support Runestone Academy Today

Before you keep reading...

Making great stuff takes time and $$. If you appreciate the book you are reading now and want to keep quality materials free for other students please consider a donation to Runestone Academy. We ask that you consider a $10 donation, but if you can give more thats great, if $10 is too much for your budget we would be happy with whatever you can afford as a show of support.

Support Runestone Academy Today

8.1. Intro to ArrayLists

Figure 1: A couple of lists

In the last unit, we learned about arrays to hold collections of related data. But arrays have limitations. The size of an array is established at the time of creation and cannot be changed. What if you don’t know how big the collection of data will be? What if you want to add and remove items from the collection and change the size of the collection while the program is running? For example, if you wanted to represent a shopping list, you might add to the list throughout the week and remove things from the list while you are shopping. You probably would not know how many items will be on the list at the beginning of the week.

Luckily, Java has a class called ArrayList which is a re-sizable array. An ArrayList has an underlying array that grows or shrinks as needed. You can use ArrayList instead of arrays whenever you don’t know the size of the array you need or you know that you will add and remove items and may need to change the array’s size dynamically during run time. An ArrayList is mutable, meaning it can change during runtime by adding and removing objects from it.

8-1-1: Which of the following is a reason to use an ArrayList instead of an array?

• A list will always use less memory than an array.
• No, an ArrayList grows as needed so it will typically be bigger than the data you put it in. If you try to add more data and the array is full, it usually doubles in size.
• A list can store objects, but arrays can only store primitive types.
• No, you can have an array of objects.
• A list has faster access to the last element than an array.
• No, an ArrayList is implemented using an array so it has the same access time to any index as an array does.
• A list resizes itself as necessary as items are added, but an array does not.
• An ArrayList is really a dynamic array (one that can grow or shrink as needed).

8.1.1. Import Package

The ArrayList class is in the java.util package. A package is a set or library of related classes. The java.lang package is the main Java language classes that you get automatically without importing it. The java.util package has a lot of utility classes that you can use if you import the package. If you want to use any class other than those in java.lang you will need to either use the full name (packageName.ClassName) like (java.util.ArrayList) or use one or more import statements to import in that package.

Import statements have to be the first code in a Java source file. An import statement tells Java which class you mean when you use a short name (like ArrayList). It tells Java where to find the definition of that class.

You can import just the classes you need from a package as shown below. Just provide an import statement for each class that you want to use.

import java.util.ArrayList; // import just the ArrayList class

Another option is to import everything at the same level in a package using import packageName.*.

import java.util.*; // import everything in package including ArrayList

Check your understanding

8-1-2: Which of the following is true about import statements?

• You can only have one import statement in a source file.
• You can have an many import statements as you need.
• You must specify the class to import.
• You can use * to import all classes at the specified level.
• Import statements must be before other code in a Java source file.
• Import statements have to be the first Java statements in a source file.
• You must import java.lang.String to use the short name of String.
• You do not have to import any classes that are in the java.lang package.

8.1.2. Declaring and Creating ArrayLists

To declare a ArrayList use ArrayList<Type> name Change the Type to be whatever type of objects you want to store in the ArrayList, for example String as shown in the code below. You don’t have to specify the generic type <Type>, since it will default to Object, but it is good practice to specify it to restrict what to allow in your ArrayList. Using a type ArrayList<Type> is preferred over just using ArrayList because it allows the compiler to find errors that would otherwise be missed until run-time.

// ArrayList<Type> name = new ArrayList<Type>();
// An ArrayList of Strings:
ArrayList<String> shoppingList = new ArrayList<String>();

Note

ArrayLists can only hold objects like String and the wrapper classes Integer and Double. They cannot hold primitive types like int, double, etc.

Coding Exercise

In the code below we are declaring a variable called nameList that can refer to a ArrayList of strings, but currently doesn’t refer to any ArrayList yet (it’s set to null).

import java.util.*; // import for ArrayList public class ArrayListDeclare { public static void main(String[] args) { ArrayList<String> nameList = null; System.out.println(nameList); } } ==== import static org.junit.Assert.*; import org.junit.*;; import java.io.*; public class RunestoneTests extends CodeTestHelper { public RunestoneTests() { super("ArrayListDeclare"); } @Test public void test1() { String output = getMethodOutput("main"); String expect = "null"; boolean passed = getResults(expect, output, "main()", true); assertTrue(passed); } }

Declaring a ArrayList doesn’t actually create a ArrayList. It only creates a variable that can refer to a ArrayList. To actually create a ArrayList use new ArrayList<Type>(). If you leave off the <Type> it will default to Object.

You can get the number of items in a ArrayList using the size() method. Notice that an empty ArrayList has a size of 0 because the ArrayList constructor constructs an empty list. Also notice that you can’t get the size of a ArrayList that is currently set to null on line 9. You will get a NullPointerException instead, which means that you tried to do something with an object reference that was null (doesn’t exist).

The following code demonstrates a NullPointerException. Change list2 so that it creates a new Arraylist to remove the NullPointerException.

import java.util.*; // import everything at this level public class ArrayListCreateStr { public static void main(String[] args) { ArrayList<String> nameList = new ArrayList<String>(); System.out.println("The size of nameList is: " + nameList.size()); ArrayList<String> list2 = null; System.out.println("The size of list2 is: " + list2.size()); } }

You can also create ArrayLists of integer values. However, you have to use Integer as the type because ArrayLists can only hold objects, not primitive values. All primitive types must be wrapped in objects before they are added to an ArrayList. For example, int values can be wrapped in Integer objects, double values can be wrapped in Double objects. You can actually put in any kind of Objects in an ArrayList, even for a class that you wrote in Unit 5 like Student or Person or Pet.

Here’s an example of a Integer ArrayList:

import java.util.*; // import everything at this level public class ArrayListCreateInt { public static void main(String[] args) { ArrayList<Integer> numList = new ArrayList<Integer>(); System.out.println(numList.size()); } }

Check your understanding

8-1-6: Which of the following is the correct way to create an ArrayList of integers?

• ArrayList[int] numbers = new ArrayList();
• The square brackets [] are only used with arrays, not ArrayLists.
• ArrayList<String> numbers = new ArrayList();
• String is not the correct type since this is for an array of integers, and the type should be next to ArrayList on both sides.
• ArrayList<int> numbers = new ArrayList<int>();
• ArrayLists cannot hold primitive types like int. You must use the wrapper class Integer.
• ArrayList<Integer> numbers = new ArrayList<Integer>();
• The wrapper class Integer is used to hold integers in an ArrayList.

Although it is not on the AP exam, you can convert arrays to ArrayLists using its constructor with an argument Arrays.asList(arrayname) like the following. Note that ArrayLists have a toString() method that is automatically called to print the list in a nice format.

import java.util.*; public class ArrayListFromArray { public static void main(String[] args) { String[] names = {"Dakota", "Madison", "Brooklyn"}; ArrayList<String> namesList = new ArrayList<String>(Arrays.asList(names)); System.out.println(namesList); } }

Coding Exercise

You can add values to an ArrayList by using its add method, described in detail in the next lesson. Try the code below. Note that the type of the ArrayList, String or Integer, also determines the type of parameters and return types for all of its methods, so add and print work for any type of ArrayList.

Can you add another item to the shopping list?

import java.util.*; public class Shopping { public static void main(String[] args) { ArrayList<String> shoppingList = new ArrayList<String>(); System.out.println("Size: " + shoppingList.size()); shoppingList.add("carrots"); System.out.println(shoppingList); shoppingList.add("bread"); System.out.println(shoppingList); shoppingList.add("chocolate"); System.out.println(shoppingList); System.out.println("Size: " + shoppingList.size()); ArrayList<Integer> quantities = new ArrayList<Integer>(); quantities.add(2); quantities.add(4); System.out.println(quantities); } } ==== import static org.junit.Assert.*; import org.junit.*;; import java.io.*; public class RunestoneTests extends CodeTestHelper { public RunestoneTests() { super("Shopping"); } @Test public void test1() { String output = getMethodOutput("main"); String expect = "Size: 0\n[carrots]\n[carrots, bread]\n[carrots, bread, chocolate]\nSize: 3\n[2, 4]"; boolean passed = !output.equals(expect); passed = getResults(expect, output, "Changes to main()", passed); assertTrue(passed); } }

8.1.3. Programming Challenge : FRQ Digits

In this question, you are asked to write a constructor for a class called Digits. This constructor takes an integer number as its argument and divides it up into its digits and puts the digits into an ArrayList. For example, new Digits(154) creates an ArrayList with the digits [1, 5, 4].

First, let’s discuss how to break up a number into its digits. Try the code below. What happens if you divide an integer by 10? Remember that in integer division the result truncates (cuts off) everything to the right of the decimal point. Which digit can you get by using mod 10 which returns the remainder after dividing by 10? Try a different number and guess what it will print and then run to check.

Set number to a different number and guess what number / and % will return. Which operator gives you a digit in number?

public class DivideBy10 { public static void main(String[] args) { int number = 154; System.out.println(number / 10); System.out.println(number % 10); } } ==== import static org.junit.Assert.*; import org.junit.*;; import java.io.*; public class RunestoneTests extends CodeTestHelper { public RunestoneTests() { super("DivideBy10"); } @Test public void test1() { String output = getMethodOutput("main"); String expect = "15\n4"; boolean passed = !output.equals(expect); passed = getResults(expect, output, "Try another number", passed); assertTrue(passed); } }

We can us a while loop to print out each digit in reverse order starting from the right (4, 5, 1 for the number 154) while dividing it by 10. You can try it in the active code above. Here is the pseudocode:

• while number is greater than 0

  • print out the last digit using %

  • change the number to cut off the last digit using /

Now, let’s write a constructor for the Digits class that uses this loop and adds each found digit to the ArrayList instead of printing it out. You can use a special method called Collections.reverse(digitsList); to reverse the order of the digits in the ArrayList after the loop to get them in the right order. In the next lesson, we will also learn how to use a different add method that adds in elements at any index instead of the end.

Complete the challenge below to put the digits of a number in an ArrayList.

import java.util.*; public class Digits { /** A list of digits */ private ArrayList<Integer> digitList; /** Constructs a list of digits from the given number */ public Digits(int number) { // initialize digitList to an empty ArrayList of Integers // Use a while loop to add each digit in number to digitList //Use Collections.reverse(digitList); to reverse the digits } /** returns the string representation of the digits list */ public String toString() { return digitList.toString(); } public static void main(String[] args) { Digits d1 = new Digits(154); System.out.println(d1); } } ==== import static org.junit.Assert.*; import org.junit.*;; import java.io.*; public class RunestoneTests extends CodeTestHelper { public RunestoneTests() { super("Digits"); } @Test public void test1() { String output = getMethodOutput("main"); String expect = "[1, 5, 4]"; boolean passed = getResults(expect, output, "Digits(154)"); assertTrue(passed); } @Test public void test2() { Digits test = new Digits(123456); String output = test.toString(); String expect = "[1, 2, 3, 4, 5, 6]"; boolean passed = getResults(expect, output, "Digits(123456)"); assertTrue(passed); } }

8.1.4. Summary

• ArrayList are re-sizable arrays that allow adding and removing items to change their size during run time.

• The ArrayList class is in the java.util package. You must import java.util.* to use it.

• An ArrayList object contains object references and is mutable, meaning it can change (by adding and removing items from it).

• The ArrayList constructor ArrayList() constructs an empty list of size 0.

• Java allows the generic type ArrayList<E>, where the generic type E specifies the type of the elements, like String or Integer. Without it, the type will be Object.

• ArrayList<E> is preferred over ArrayList because it allows the compiler to find errors that would otherwise be found at run-time.

• When ArrayList<E> is specified, the types of the reference parameters and return type when using its methods are type E.

• ArrayLists cannot hold primitive types like int or double, so you must use the wrapper classes Integer or Double to put numerical values into an ArrayList.

You have attempted of activities on this page