Skip to main content

Subgoals

Section 14.3 Worked Example: Writing ArrayLists - Shifting Values

Subgoals for Evaluating ArrayLists.

  1. Importing the ArrayList class
    🔗
    1. Before using ArrayList, import it from the java.util package:
      🔗
      import java.util.ArrayList;
      🔗
      🔗
    🔗
    🔗
  2. 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;
      🔗
      🔗
    🔗
    🔗
  3. 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+)
      🔗
      🔗
    🔗
    🔗
  4. 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
      🔗
      🔗
    🔗
    🔗
  5. 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
      🔗
      🔗
    🔗
    🔗
  6. 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
      🔗
      🔗
    🔗
    🔗
  7. 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.3.1

Problem: Write the Java code that will create an ArrayList of integers with the values 5, 10, 15, … 55 (multiples of 5). But then you remember you were supposed to start at 0, not 5 - so write the Java code that will shift all the values to the right by 1. In other words, the value 5 will shift from index 0 to index 1. And then you can put the value 0 at index 0.
🔗
🔗

Subsection 14.3.2 SG1: Declaring an ArrayList variable and SG2: Instantiating an ArrayList object

Because all multiples of 5 are integers, the datatype stored in the ArrayList should be Integer. We will name the variable alpha. We also need to import the ArrayList class and use the wrapper class Integer for primitive type int:
🔗
import java.util.ArrayList;

ArrayList<Integer> alpha = new ArrayList<Integer>();
Now, we’ll add the multiples of 5 from 5 to 55 using a loop:
🔗
for (int i = 5; i <= 55; i += 5) {
    alpha.add(i);
}
🔗

Subsection 14.3.3 SG5: Traversing and Shifting an ArrayList

To shift the values to the right by one position, we must do a reverse traversal. We start from the last index and move each element to the next higher index. Then, we set the first index to 0:
🔗
for (int i = alpha.size() - 1; i > 0; i--) {
    alpha.set(i, alpha.get(i - 1));
}
alpha.set(0, 0);
It’s important to go backwards so we don’t overwrite values before we’ve moved them. If we went forward, we’d end up copying the same value multiple times.
🔗
🔗
Answer.
import java.util.ArrayList;

ArrayList<Integer> alpha = new ArrayList<Integer>();
for (int i = 5; i <= 55; i += 5) {
    alpha.add(i);
}
for (int i = alpha.size() - 1; i > 0; i--) {
    alpha.set(i, alpha.get(i - 1));
}
alpha.set(0, 0);
🔗

Subsection 14.3.4 Practice Pages

🔗
You have attempted 1 of 2 activities on this page.
🔗
PrevTopNext