Writing-ArrayLists-WE2-P1

Section 14.4 Writing-ArrayLists-WE2-P1

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<>()
    🔗
    
    🔗
  🔗
  🔗
🔗
🔗

🔗

Subsection 14.4.1

Exercises Exercises

1.

Q4: What are the contents of alpha after this code has been executed?

🔗

import java.util.ArrayList;

ArrayList<Integer> alpha = new ArrayList<>();
Collections.addAll(alpha, 10, 20, 30, 40, 50, 60, 70);

int start = alpha.get(alpha.size() - 1);
for (int i = 1; i < alpha.size(); i++) {
    alpha.set(i, alpha.get(i - 1));
}
alpha.set(0, start);

{20, 30, 40, 50, 60, 70, 10}
🔗
Incorrect
{10, 20, 30, 40, 50, 60, 70}
🔗
Incorrect
{10, 10, 20, 30, 40, 50, 60}
🔗
Incorrect
{70, 10, 10, 10, 10, 10, 10}
🔗
Correct
{10, 10, 10, 10, 10, 10, 10}
🔗
Incorrect

🔗

2.

Q5: What are the contents of beta after this code has been executed?

🔗

import java.util.ArrayList;

ArrayList<Integer> beta = new ArrayList<>();
Collections.addAll(beta, 10, 20, 30, 40, 50, 60, 70);

for (int i = 1; i < beta.size(); i++) {
    beta.set(i, beta.get(i - 1));
}

{20, 30, 40, 50, 60, 70, 10}
🔗
Incorrect
{10, 20, 30, 40, 50, 60, 70}
🔗
Incorrect
{10, 10, 20, 30, 40, 50, 60}
🔗
Incorrect
{70, 10, 20, 30, 40, 50, 60}
🔗
Incorrect
{10, 10, 10, 10, 10, 10, 10}
🔗
Correct

🔗

3.

Q6: What happens when this code is executed on gamma?

🔗

import java.util.ArrayList;

ArrayList<Integer> gamma = new ArrayList<>();
Collections.addAll(gamma, 10, 20, 30, 40, 50, 60, 70);

for (int i = 0; i < gamma.size(); i++) {
    gamma.set(i, gamma.get(i + 1));
}

{20, 30, 40, 50, 60, 70, 70}
🔗
Incorrect
{20, 30, 40, 50, 60, 70, 10}
🔗
Incorrect
{10, 20, 30, 40, 50, 60, 70}
🔗
Incorrect
{10, 10, 20, 30, 40, 50, 60}
🔗
Incorrect
IndexOutOfBounds Exception
🔗
Correct

🔗

You have attempted 1 of 3 activities on this page.

🔗

Prev Top Next