Practice: ArrayList

Question #1: Which of the following will correctly create an ArrayList that holds double values?

List option1 = new ArrayList<double>();
List<double> option2 = new List<>();
List<Double> option3 = new ArrayList<>();
List<> option4 = new ArrayList<Double>();
ArrayList<Double> option5 = new List<>();

Click to see answer

The correct answer is option3.
Recall:

• An ArrayList may only contain Object types. We must use Double (captial-D).

• The new operator must instantiate a concrete type. List is not a concrete type.

Question #2: Which of the following lines have Boxing or Unboxing?

    List<Integer> list = new ArrayList<>();
    list.add(5);
    int n0 = list.get(0);
    Integer n1 = list.get(0);
    Integer num = 11;
    int n2 = num;
    int n3 = num.intValue();
    Integer num2 = Integer.valueOf(11);
    Integer num3 = num.intValue();

Click to see answer

See the table:

line	code	Auto-boxing	Auto-Unboxing	Boxing (explicit)	Unboxing (explicit)
2	list.add(5);	✅
3	int n0 = list.get(0);		✅
4	Integer n1 = list.get(0);
5	Integer num = 11;	✅
6	int n2 = num;		✅
7	int n3 = num.intValue();				✅
8	Integer num2 = Integer.valueOf(11);			✅
9	Integer num3 = num.intValue();	✅			✅

Question #3: What is the output of the following code?

    ArrayList<String> words = new ArrayList<String>();
    words.add("Olympia");
    words.add("Everett");
    words.add("Tacoma");
    words.add("Woodinville");
    words.set(1, "Bothell");
    words.add(3, "Kenmore");
    words.remove(0);
    if (!words.contains("Olympia")) {
        String word = words.get(words.indexOf("Kenmore") + 1);
        System.out.println(word);
    } else {
        System.out.println(words.get(1));
    }

Click to see answer

The output is: `Woodinville`

This is because the list progresses as shown below. After line 8, the list does not contain "Olympia" so it gets the element that is after "Kenmore".

Index	After line 5	After line 7	After line 8
0	Olympia	Olympia	Bothell
1	Everette	Bothell	Tacoma
2	Tacoma	Tacoma	Kenmore
3	Woodinville	Kenmore	Woodinville
4		Woodinville

Question #4: Write a method that will accept an ArrayList<String> and manually remove all occurrences of the argument removeMe. There are several ways to do this. How many can you implement?

Click to see answer

// Method 1: The most basic and expected answer.
// To remove all instances, we need to traverse the list backwards
public static void removeAll(ArrayList<String> list, String removeMe) {

    // iterate backwards. If not, we'll erroneously skip items.
    for (int i = list.size() - 1; i >= 0; i--) {
        if (list.get(i).equals(removeMe)) {
            list.remove(i);
        }
    }
}  

// Method 2: Use the removeAll method.
// We need to create a Collection, or List, with removeMe in it.
public static void removeAll(ArrayList<String> list, String removeMe) {

    // Takes a Collection as an argument.
    // Use the Arrays.asList to quickly create a list with our one element.
    list.removeAll(Arrays.asList(removeMe));
}  

// Method 3: Use the iterator.
// While this uses interfaces, the fact that it uses an interface is
// essentially transparent and can be ignored.
public static void removeAll(ArrayList<String> list, String removeMe) {

    // Ask the list for an iterator that offers the ability to remove
    // an element while iterating through the list. 
    Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {
        if (iterator.next().equals(removeMe)) {
            iterator.remove();
        }
    }
}  

// Method 4: Use a lambda expression.
// This is an advanced technique. See Interfaces -> Lambdas
public static void removeAll(ArrayList<String> list, String removeMe) {
      // Removes all elements that match the condition.
      // The condition is a generic functional interface: Predicate<String>.
      // The Functional Interface is fulfilled with a Lambda Expression.
      list.removeIf(element -> element.equals(removeMe));
}  

See Also: Functional Interface.