ListADT<T> interface can now be implemented more easily by leveraging the core logic we’ve already built and tested. This demonstrates a key benefit of good design: building reusable components.
indexOf, contains, and remove(T item) all rely on searching through the list’s elements. We planned the logic for indexOf in Step 4; let’s implement it first, paying attention to null handling.
indexOf(T item)
equals. We must handle the case where the item we are searching for is null, and also the case where elements within the buffer array might be null (although our add/set methods currently prevent adding nulls, a robust indexOf should be safe).
// Inside the ArrayList<T> class...
/**
* Returns the position of the first occurrence of the specified element.
* Handles null search item correctly.
* @param item element to search for
* @return the index of the first occurrence, or -1 if not found
*/
@Override
public int indexOf(T item) {
// --- Implementation based on Step 4 Skeleton ---
// 1. Iterate through the list elements with index 'i' from 0 to size - 1.
for (int i = 0; i < this.size; i++) {
// 2. Inside loop, compare 'item' with buffer[i] using null-safe equals.
T currentElement = this.buffer[i];
if (item == null) {
// If searching for null, find the first null element
if (currentElement == null) {
return i; // Found null at index i
}
} else {
// If searching for non-null, use item.equals()
// Ensure currentElement isn't null before calling equals on it
// (Though our current implementation prevents null elements)
if (item.equals(currentElement)) {
return i; // Found match at index i
}
}
}
// 4. If loop finishes without finding a match, return -1.
return -1;
}
java.util.Objects.equals(a, b). This static method correctly handles cases where a or b (or both) might be null. Our loop logic implements this behavior directly.
contains(T item)
indexOf(item) returns a non-negative index.
// Inside the ArrayList<T> class...
@Override
public boolean contains(T item) {
// --- Implementation based on Step 4 Skeleton (Leveraging indexOf) ---
// 1. Perform the logic for indexOf(item).
// 2. Return true if the index found is not -1.
return indexOf(item) >= 0;
}
remove(T item)
indexOf to find the item, and then uses our core remove(int index) method if the item is found.
// Inside the ArrayList<T> class...
@Override
public boolean remove(T item) {
// --- Implementation based on Step 4 Skeleton ---
// 1. Find the index of the first occurrence of 'item'.
int foundIndex = indexOf(item); // Reuse indexOf()
// 2. Check if the item was found.
if (foundIndex >= 0) {
// Bounds check is implicit (foundIndex is 0 to size-1)
// Store item (optional, not needed for boolean return)
// T removedItem = this.buffer[foundIndex];
// If removing before the last one, shift left (Call helper)
if (foundIndex < this.size - 1) {
shiftLeft(foundIndex);
}
// Decrement size
this.size--;
// Null out now-unused slot (Help GC)
this.buffer[this.size] = null;
return true; // Indicate success
} else {
// 4. If not found, return false.
return false;
}
}
first, last)
get.
// Inside the ArrayList<T> class...
@Override
public T first() {
// --- Implementation based on Step 4 Skeleton ---
// 1. Check if empty
if (isEmpty()) { // Reuse isEmpty() method
throw new NoSuchElementException("List is empty.");
}
// 2. If not empty, delegate to get(0)
return get(0); // Reuse get() method
}
@Override
public T last() {
// --- Implementation based on Step 4 Skeleton ---
// 1. Check if empty
if (isEmpty()) { // Reuse isEmpty() method
throw new NoSuchElementException("List is empty.");
}
// 2. If not empty, delegate to get(size - 1)
return get(this.size - 1); // Reuse get() and size field/method
}
get, isEmpty, and the size field, after handling their specific preconditions (the empty check).
addFirst using its direct logic sequence. Now we implement the remaining convenience methods: removeFirst, removeLast (also using their direct logic sequences), and addAfter (which demonstrates composition by using other methods).
// Inside the ArrayList<T> class...
@Override
public T removeFirst() {
// --- Implementation based on Step 4 Skeleton ---
// 1. Check if empty
if (isEmpty()) {
throw new NoSuchElementException("List is empty.");
}
// 2. Store element at index 0
T removedItem = this.buffer[0];
// 3. Shift elements 1..size-1 left (if any exist)
if (this.size > 1) { // Check if shifting is needed
shiftLeft(0); // Call helper
}
// 4. Decrement size
this.size--;
// 5. Null out the now-unused slot at the new end
this.buffer[this.size] = null; // Help GC
// 6. Return the stored element
return removedItem;
}
@Override
public T removeLast() {
// --- Implementation based on Step 4 Skeleton ---
// 1. Check if empty
if (isEmpty()) {
throw new NoSuchElementException("List is empty.");
}
// 2. Calculate last index
int lastIndex = this.size - 1;
// 3. Store element at last index
T removedItem = this.buffer[lastIndex];
// 4. Decrement size *before* nulling out
this.size--;
// 5. Null out the now-unused slot (at the new size, which was the old lastIndex)
this.buffer[this.size] = null; // Help GC - No shifting needed!
// 6. Return the stored element
return removedItem;
}
@Override
public boolean addAfter(T existing, T item) {
// --- Implementation based on Step 4 Skeleton ---
// 1. Check null arguments
if (existing == null || item == null) {
throw new IllegalArgumentException("Existing item and new item cannot be null.");
}
// 2. Find index of existing item
int foundIndex = indexOf(existing); // Reuse indexOf()
// 3. If found...
if (foundIndex >= 0) {
int insertionIndex = foundIndex + 1;
// Index bounds check (0 <= insertionIndex <= size)
// Note: If foundIndex is valid (0 to size-1), then
// insertionIndex (1 to size) is always <= size.
// We only need to ensure it's not > size, which it won't be.
// The lower bound (>=0) is also guaranteed.
// Ensure capacity (Call helper)
growIfNeeded();
// Shift right to make space (Call helper - handles no-shift case)
shiftRight(insertionIndex);
// Place item
this.buffer[insertionIndex] = item;
// Increment size
this.size++;
return true;
} else {
// 5. If not found...
return false;
}
}
removeFirst and removeLast show the explicit sequence of checks and helper calls needed for removing from the ends. The addAfter method illustrates building functionality by combining previously implemented and tested methods (indexOf and add).
clear()
clear method needs to reset the list to an empty state. As planned in Step 4, this involves resetting the size and optionally nulling out array slots to help the garbage collector.
// Inside the ArrayList<T> class...
@Override
public void clear() {
// --- Implementation based on Step 4 Skeleton ---
// 1. Optional (Helps GC): Null out references in the array slots
// that were actually used (0 to size-1).
for (int i = 0; i < this.size; i++) {
this.buffer[i] = null;
}
// 2. Reset the size to 0.
this.size = 0;
// Note: We could also resize buffer back to DEFAULT_CAPACITY here
// if memory usage is a major concern, but it's not strictly required
// by the ADT contract. We'll omit that for simplicity now.
}
ListADT<T> interface. This is the moment of truth.
ListADT contract (including all edge cases and error handling), all tests should now pass (✅✅✅)!
AssertionError (wrong result)? What was expected vs. actual?NullPointerException)? Where did it occur in your code (check the stack trace)?IndexOutOfBoundsException)? Did your checks fail?ArrayList.java until all tests pass. Getting a completely "green" test bar is the goal.
dr-step-5.4-remaining-impl branch.
ArrayList based on the provided specification. The final part of Step 5 involves reflecting on the implementation and considering potential refinements or improvements, which we will do in the next section.
