Assessment: Write ArrayLists

Section 14.7 Assessment: Write ArrayLists

Subgoals for Evaluating ArrayLists.

Importing the ArrayList class
🔗
1. Before using ArrayList, import it from the java.util package:
  🔗
  
  import java.util.ArrayList;
  🔗
  
  🔗
🔗
🔗
Declaring an ArrayList variable
🔗
1. Determine the type of objects to be stored (use wrapper classes for primitives, e.g., Integer instead of int)
  🔗
  
  🔗
2. Determine the name of the ArrayList variable
  🔗
  
  🔗
3. Use syntax: ArrayList<DataType> name;
  🔗
  
  🔗
🔗
🔗
Instantiating an ArrayList object
🔗
1. Use the new keyword with the constructor to create a new ArrayList object
  🔗
  
  🔗
2. Assign to variable using: name = new ArrayList<>();
  🔗
  
  🔗
3. Optionally, initialize with values using: new ArrayList<>(List.of(value1, value2, ...)); (Java 9+)
  🔗
  
  🔗
🔗
🔗
Accessing an element in an ArrayList
🔗
1. Determine the index of the element to be accessed
  🔗
  
  🔗
2. Use: listName.get(index) to retrieve the element
  🔗
  
  🔗
3. Ensure the index is within bounds: 0 to listName.size() - 1, otherwise an IndexOutOfBoundsException occurs
  🔗
  
  🔗
🔗
🔗
Changing a value in an ArrayList
🔗
1. Determine the index of the element to be changed
  🔗
  
  🔗
2. Determine the new value or expression to assign
  🔗
  
  🔗
3. Use: listName.set(index, newValue) to update the value
  🔗
  
  🔗
🔗
🔗
Traversing an ArrayList
🔗
1. Decide whether accessing all elements, updating, or accessing a subset
  🔗
  
  🔗
2. If accessing only, use an enhanced for (for-each) loop:
  🔗
  1. for (DataType item : listName) - iterates from first to last, storing a copy of each element in item
    🔗
    
    🔗
  🔗
  🔗
3. If updating or using indices, use a traditional for loop:
  🔗
  1. Initialize loop control variable to 0 (or listName.size() - 1 for reverse)
    🔗
    
    🔗
  2. Set condition: i < listName.size() (or i >= 0 for reverse)
    🔗
    
    🔗
  3. Increment or decrement loop control variable appropriately
    🔗
    
    🔗
  🔗
  🔗
4. Use listName.get(i) to access or listName.set(i, newValue) to update
  🔗
  
  🔗
🔗
🔗
Whole list actions
🔗
1. Passing an ArrayList as an argument
  🔗
  1. Check if the method expects an ArrayList argument (check documentation or method signature)
    🔗
    
    🔗
  2. Pass the ArrayList variable in the method call
    🔗
    
    🔗
  3. Note: changes to the ArrayList in the method will persist (objects are passed by reference)
    🔗
    
    🔗
  🔗
  🔗
2. Reassigning an ArrayList
  🔗
  1. Determine that the reference to the list should point to a new ArrayList
    🔗
    
    🔗
  2. Left-hand side is the variable name of the original list
    🔗
    
    🔗
  3. Right-hand side is the new ArrayList, e.g., new ArrayList<>()
    🔗
    
    🔗
  🔗
  🔗
🔗
🔗

Exercises Exercises

1.

Q1: The following method is intended to return a String formed by concatenating elements from the parameter words. The elements to be concatenated start with startIndex and continue through the last element of words and should appear in reverse order in the resulting string.

🔗

import java.util.ArrayList;

// Assume words.size() > 0 and startIndex >= 0
public String concatWords(ArrayList<String> words, int startIndex) {
    String result = "";
    /* missing code */
    return result;
}

For example, the following code segment should print CarHouseGorilla:

🔗

ArrayList<String> things = new ArrayList<>();
things.add("Bear");
things.add("Apple");
things.add("Gorilla");
things.add("House");
things.add("Car");
System.out.println(concatWords(things, 2));

Which of the following code segments is a correct replacement for /* missing code */?

🔗

for (int k = startIndex; k < words.size(); k++) {
    result += words.get(k) + words.get(words.size() - k - 1);
}

II.

🔗

int k = words.size() - 1;
while (k >= startIndex) {
    result += words.get(k);
    k--;
}

III.

🔗

ArrayList<String> temp = new ArrayList<>(words);
Collections.reverse(temp);
for (int k = 0; k < temp.size() - startIndex; k++) {
    result += temp.get(k);
}

I only
🔗
II only
🔗
III only
🔗
I and II only
🔗
II and III only
🔗

🔗

2.

Q2: Consider the following two methods. What is printed as a result of the call start()?

🔗

import java.util.ArrayList;

public void changeIt(ArrayList<String> list, int num) {
    list = new ArrayList<>();
    num = 0;
    list.add("Zero");
}

public void start() {
    ArrayList<String> words = new ArrayList<>();
    words.add("One");
    words.add("Two");
    int value = 6;
    changeIt(words, value);
    System.out.println(words + " " + value);
}

[Zero] 0
🔗
[] 0
🔗
[] 6
🔗
[One, Two] 6
🔗
[One, Two, Zero] 0
🔗

🔗

3.

Q3: Consider the following two methods. What is printed as a result of the call start()?

🔗

import java.util.ArrayList;

public void modifyList(ArrayList<String> list, String word) {
    list.add(word.substring(0, 5));
    word = "Changed";
}

public void start() {
    ArrayList<String> items = new ArrayList<>();
    items.add("Red");
    items.add("Blue");
    String label = "Magenta";
    modifyList(items, label);
    System.out.println(items + " " + label);
}

[Red, Blue, Magen] Magenta
🔗
[Red, Blue, Changed] Changed
🔗
[Red, Blue] Magenta
🔗
[Red, Blue] Changed
🔗
[Magen] Magenta
🔗

🔗

You have attempted 1 of 2 activities on this page.

🔗

Prev TopNext