Assessment: Write ArrayLists

Section 14.7 Assessment: Write ArrayLists

Subgoals for Writing 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 (When ArrayLists are instantiated, they are empty and have a size of 0.)
  🔗
  
  🔗
🔗
🔗
Adding elements to an ArrayList
🔗
1. To add to the end of an ArrayList, use: listName.add(valueToBeAdded)
  🔗
  
  🔗
2. To add an element at a specific location in an ArrayList, use: listName.add(index, valueToBeAdded) where index is within the bounds 0 to listName.size()
  🔗
  
  🔗
🔗
🔗
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
  🔗
  
  🔗
4. Ensure the index is within bounds: 0 to listName.size() - 1, otherwise an IndexOutOfBoundsException occurs
  🔗
  
  🔗
🔗
🔗
Traversing an ArrayList
🔗
1. Decide whether accessing all elements, updating, or accessing a subset
  🔗
  
  🔗
2. If only accessing elements, 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 Subgoals 5 or 6 to access or change values as appropriate
  🔗
  
  🔗
🔗
🔗
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. When calling a method, pass a reference to an ArrayList (usually variable name) as an argument in the method call.
    🔗
    
    🔗
  3. Note: changes to elements in the ArrayList that are done inside the method will persist
    🔗
    
    🔗
  🔗
  🔗
🔗
🔗

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