Review AP CSA Unit 4 to build fluency with arrays, ArrayLists, 2D arrays, searching, sorting, and recursion. This unit carries 30-40% of the exam and demands both code-tracing accuracy and algorithm implementation skill.
Use the topic guides, key terms, and practice questions available on Fiveable to work through every concept before exam day.
Unit 4 is the largest unit in AP CSA by exam weight. It introduces three data structures for storing groups of related values, arrays, ArrayLists, and 2D arrays, and then builds a library of standard algorithms on top of them. The unit also opens with ethical questions about privacy and bias that apply whenever programs collect and process real data.
Unit 4 teaches you how to store, access, traverse, search, sort, and recursively process collections of data in Java, while also asking you to think critically about the social implications of data collection.
A 1D array has a fixed length set at creation and uses arr[i] indexing. An ArrayList is dynamically sized and uses methods like add(), remove(), get(), and set(). A 2D array is an array of arrays accessed with arr[row][col] and traversed with nested loops.
Every data structure supports the same family of algorithms: find min or max, compute sum or average, count or check elements for a property, detect duplicates, shift or reverse elements, and insert or delete. Knowing these patterns for arrays, ArrayLists, and 2D arrays is the core skill of the unit.
Linear search checks elements one at a time. Binary search cuts a sorted collection in half each step. Selection sort swaps the minimum into place; insertion sort shifts elements to insert each new value. Merge sort recursively splits and merges. Recursion itself requires tracing base cases and recursive calls through a call stack.
Arrays, ArrayLists, and 2D arrays are the building blocks of almost every non-trivial Java program. The AP exam tests whether you can read code that manipulates these structures, predict its output, identify bugs, and write new algorithms. Because this unit accounts for 30-40% of the exam, a strong grasp of traversal patterns, index arithmetic, and algorithm tracing pays off across both the multiple-choice and free-response sections.
Privacy risks from storing personal data, algorithmic bias from flawed data sets, and how to evaluate whether a data set is appropriate for a given question.
A data set is a collection of related information processed one element at a time. Charts and tables help plan the algorithm before writing code.
1D arrays store fixed-length collections of same-type values. Created with new or an initializer list; accessed with arr[i]; valid indices are 0 to arr.length - 1.
Indexed for loops and while loops allow element modification; enhanced for loops provide read-only access. Assigning to the enhanced for variable does not change the array.
Standard algorithms include min/max, sum/average, existential and universal checks, count, consecutive pair access, duplicate detection, shift, rotate, and reverse.
Use File(String) and Scanner(File) to read persistent data. The method header must declare throws IOException. Use hasNext() in a while loop to read all tokens.
Integer and Double wrap primitives as objects. Autoboxing and unboxing happen automatically. Integer.parseInt() and Double.parseDouble() convert Strings to numbers.
ArrayList is a dynamically sized list from java.util. Core methods: size(), add(E), add(int, E), get(int), set(int, E), remove(int). Use ArrayList for compile-time type safety.
Use indexed for loops when adding or removing elements during traversal. Enhanced for loops throw ConcurrentModificationException if the list size changes inside the loop.
Same standard algorithms as arrays: min, max, sum, average, count, property checks, duplicates, shift, rotate, reverse, insert, and delete. Decrement the index after removing an element.
A 2D array is an array of arrays. Created with new int[rows][cols] or a nested initializer list. Access with arr[row][col]; row count is arr.length, column count is arr[0].length.
Nested for loops traverse in row-major or column-major order. The outer enhanced for variable is a 1D array (a row); the inner variable is the element type.
Apply standard algorithms to the full 2D array or to a specific row, column, or subsection. Track both row and column indices to process the correct region.
Linear search checks each element in order and works on any data. For 2D arrays, apply linear search row by row. Return the index or -1 if not found.
Selection sort swaps the minimum of the unsorted portion into its final position each pass. Insertion sort shifts elements to insert each new value into the sorted prefix.
A recursive method calls itself with a base case to stop and a recursive call that moves toward it. Each call has its own local variables. Trace calls from the base case outward. Writing recursion is outside exam scope.
Binary search requires sorted data and halves the search space each step. Merge sort splits to single elements then merges in order. Both run more efficiently than linear search and O(n^2) sorts on large inputs.
Review 2D arrays in AP Computer Science A, including Java int[][] syntax, arr[row][col], default values, initializer lists, and length.
Review AP CSA array algorithms, including traversals, min/max, sums, counting, duplicate checks, consecutive pairs, shifting, rotating, and reversing arrays.
This snapshot uses Fiveable practice activity to show where students tend to miss questions and which review moves are worth prioritizing first.
Across 6.9k multiple-choice practice attempts for this unit.
Practice activity included in this snapshot.
Before writing any code, AP CSA asks you to think about the human side of data. Topic 4.1 covers privacy risks and algorithmic bias; Topic 4.2 introduces the idea of a data set and how to plan algorithms that process it.
Can you explain two ways algorithmic bias can enter a program, and describe what makes a data set appropriate for a given question?
| Issue | Cause | Programmer response |
|---|---|---|
| Privacy breach | Storing unnecessary PII | Collect only what is needed; protect stored data |
| Algorithmic bias | Biased or unrepresentative training data | Audit data collection method before use |
| Incomplete data | Missing records or fields | Verify data set completeness before drawing conclusions |
A 1D array stores multiple values of the same type under one variable. Its length is fixed at creation. You access elements with arr[i], where valid indices run from 0 to arr.length - 1. Traversal uses an indexed for loop, a while loop, or an enhanced for loop depending on whether you need to modify elements.
Trace this loop: int[] a = {4, 1, 3}; for (int i = a.length - 1; i >= 0; i--) System.out.print(a[i] + " "); What prints?
| Loop type | Can modify elements? | Needs index? | Best use |
|---|---|---|---|
| Indexed for loop | Yes | Yes | Modify elements, access by position |
| While loop | Yes | Yes | Variable step size or early exit |
| Enhanced for loop | No (primitives) | No | Read-only traversal of all elements |
Every standard array algorithm is a traversal with a specific accumulation or comparison pattern. Know how to implement and trace each one.
Write the loop condition and body to find the index of the maximum value in an int array named scores.
Topic 4.6 covers reading persistent data from a file using File and Scanner. Topic 4.7 introduces Integer and Double wrapper classes, which are required when storing primitives in an ArrayList.
What two import statements are needed to read from a file, and what happens if the file name passed to the File constructor does not exist?
| Wrapper class | Primitive | Parse method | Immutable? |
|---|---|---|---|
| Integer | int | Integer.parseInt(String) | Yes |
| Double | double | Double.parseDouble(String) | Yes |
An ArrayList is a dynamically sized list of object references from java.util. Its five core methods are size(), add(E), add(int, E), get(int), set(int, E), and remove(int). Traversal and algorithms follow the same patterns as arrays but require careful handling when the list size changes during a loop.
An ArrayList contains [5, 3, 8, 3, 2]. Write the loop that removes all elements equal to 3 without skipping any element.
| Method | Returns | Effect on size |
|---|---|---|
| size() | int | None |
| add(E) | void | Increases by 1 |
| add(int, E) | void | Increases by 1, shifts right |
| remove(int) | E (removed element) | Decreases by 1, shifts left |
| set(int, E) | E (previous element) | None |
A 2D array is an array of arrays. You create it with new int[rows][cols] or an initializer list, access elements with arr[row][col], get the row count from arr.length, and the column count from arr[0].length. Nested loops traverse in row-major or column-major order.
Write nested for loops that compute the sum of all elements in a 2D int array named grid with r rows and c columns.
| Traversal order | Outer loop variable | Inner loop variable | Typical use |
|---|---|---|---|
| Row-major | row index i | column index j | Process each row left to right |
| Column-major | column index j | row index i | Process each column top to bottom |
Linear search checks each element in order until the target is found or the collection is exhausted. It works on unsorted and sorted data and can start from either end. For 2D arrays, apply linear search row by row using nested loops.
Trace a linear search for the value 7 in the array [2, 9, 7, 4, 1]. How many comparisons are made before the value is found?
Both algorithms sort in place and run in O(n^2) time. Selection sort minimizes swaps; insertion sort is efficient on nearly sorted data. The exam asks you to trace each pass, not write the full algorithm from scratch.
Trace selection sort on [5, 2, 8, 1, 4]. What does the array look like after two complete passes?
| Algorithm | Key operation | Swaps per pass | Best case |
|---|---|---|---|
| Selection sort | Find min, swap into position | Exactly 1 | O(n^2) comparisons |
| Insertion sort | Shift elements, insert key | 0 to many | O(n) when already sorted |
A recursive method calls itself. Every recursive method needs at least one base case that stops the recursion and at least one recursive call that moves toward the base case. On the AP exam, you trace recursive calls and determine the return value; writing recursive code is outside exam scope.
Trace mystery(4) where mystery(int n) returns 0 if n == 0, else returns n + mystery(n - 1). What is the return value?
Topic 4.17 applies recursion to searching and sorting. Binary search requires sorted data and eliminates half the collection each step. Merge sort recursively splits a collection to single elements and merges them back in order. Both can be written iteratively or recursively; the exam asks you to trace them.
Trace binary search for the value 14 in [2, 5, 8, 11, 14, 17, 20]. List the mid value checked at each step.
| Algorithm | Precondition | Strategy | Time complexity |
|---|---|---|---|
| Linear search | None | Check each element in order | O(n) |
| Binary search | Sorted data | Eliminate half each step | O(log n) |
| Selection sort | None | Swap min into place each pass | O(n^2) |
| Insertion sort | None | Insert each element into sorted prefix | O(n^2) worst, O(n) best |
| Merge sort | None | Split then merge recursively | O(n log n) |
Try AP-style multiple-choice questions and written prompts after you review the notes.
A timed, AP-style test built only from unit 4 questions — multiple choice plus free response, scored with AI feedback. Use the standard format or build your own.
| Term | Definition |
|---|---|
| Traversal | The process of visiting and accessing each element in a data structure such as an array or ArrayList in a specific order, typically using a for loop or while loop. |
| object reference | A memory address that a reference-type variable holds, allowing it to access an object stored in memory. ArrayLists store object references, not primitive values directly. |
| generic type | A Java feature using angle brackets to specify the element type of a collection; for example, ArrayList<String> restricts the list to String objects and enables compile-time type checking. |
| out-of-bounds error | An error thrown at runtime when code attempts to access an index that is negative or greater than or equal to the length of an array or the size of an ArrayList. |
| file | Storage for data that persists when a program is not running. In Java, a File object and a Scanner are used together to read data from a text file during program execution. |
| row index | The first index in arr[row][col] notation for a 2D array, specifying which row the element is located in. The number of rows is given by arr.length. |
| column index | The second index in arr[row][col] notation for a 2D array, specifying which column the element is located in. The number of columns is given by arr[0].length. |
| .get() method | An ArrayList method that retrieves the element at a specified index. Syntax: list.get(i) returns the element at index i without removing it. |
| maximum tracking | A standard algorithm pattern that initializes a variable to the first element and updates it whenever a larger element is found during traversal of an array or ArrayList. |
| shift algorithm | A standard algorithm that moves elements within an array or 2D array row in a specified direction, with the displaced element either lost or wrapped to the other end. |
| duplicate elements | An algorithm task that checks whether an array or ArrayList contains repeated values, typically using nested loops or a comparison of each element against all others. |
| boolean array | An array whose elements are of type boolean, initialized to false by default when created with new. Useful for tracking which elements satisfy a condition. |
Valid array indices are 0 to arr.length - 1, and valid ArrayList indices are 0 to list.size() - 1. Using <= arr.length or <= list.size() as the loop condition throws an out-of-bounds exception on the last iteration.
Adding or removing elements inside an enhanced for loop over an ArrayList causes a ConcurrentModificationException. Use an indexed for loop and adjust the index variable after a removal.
Assigning a new value to the enhanced for loop variable only changes the local copy; the array element is unchanged. Use an indexed loop with arr[i] = newValue to actually modify the array.
Binary search only works correctly when the collection is already sorted. Applying it to unsorted data produces wrong results without throwing an exception, making the bug hard to detect.
Arrays use the length attribute without parentheses: arr.length. Strings use the length() method with parentheses. Mixing these up causes a compile-time error.
A large portion of AP CSA multiple-choice questions present a short method that traverses an array, ArrayList, or 2D array and ask what value is returned or printed. Practice tracing loop variables, index values, and accumulator variables step by step. Pay close attention to loop bounds, the difference between < and <=, and what happens when remove() is called inside a loop.
Free-response questions frequently ask you to write a method that processes an array or ArrayList using a standard algorithm pattern such as finding a maximum, filtering elements, or comparing consecutive pairs. You are expected to use correct Java syntax, choose the right loop type, and handle edge cases like an empty list or a single-element array. Wrapper classes and autoboxing appear when the method works with ArrayList or ArrayList.
Questions on searching and sorting ask you to trace the state of a collection after a specific number of passes or iterations. For binary search, you identify the mid index and which half is eliminated at each step. For selection sort and insertion sort, you show the array after each outer-loop pass. For merge sort, you trace the split and merge phases. Knowing the sorted-order precondition for binary search is a common discrimination point.
Create a 1D array with new and with an initializer list. Access and modify elements using arr[i]. Trace indexed for loops, while loops, and enhanced for loops. Implement min, max, sum, shift, and reverse algorithms.
Declare an ArrayList, call size(), add(), get(), set(), and remove() correctly. Trace what happens to indices when an element is removed. Avoid ConcurrentModificationException by using an indexed loop when modifying the list.
Create a 2D array and access elements with arr[row][col]. Use arr.length and arr[0].length for loop bounds. Write nested loops for row-major and column-major traversal. Apply standard algorithms to rows, columns, and the full array.
Write the File and Scanner constructor calls needed to open a file. Add throws IOException to the method header. Explain autoboxing and unboxing. Use Integer.parseInt() and Double.parseDouble() to convert file data.
Trace linear search on an array, ArrayList, and 2D array. Trace selection sort and insertion sort pass by pass. State the sorted-order precondition for binary search and trace each step of a binary search.
Identify the base case and recursive call in a given recursive method. Trace the call stack to find the return value. Trace merge sort through the split and merge phases. Explain why binary search and merge sort are more efficient than their linear counterparts.
Explain two privacy risks from storing personal data. Define algorithmic bias and give an example of how biased data causes it. Evaluate whether a given data set is appropriate for a specific question.
Read the topic guides for 4.1 through 4.5. Practice explaining algorithmic bias in your own words. Then write and trace array creation, access, and the standard traversal algorithms: min, max, sum, shift, and reverse. Use the available practice questions to check your index arithmetic.
Work through the topic guides for 4.6 and 4.7 to understand file reading and autoboxing. Then study ArrayList methods in 4.8, practice the removal-during-traversal pattern from 4.9, and implement the standard ArrayList algorithms from 4.10. Compare ArrayList and array behavior side by side.
Review 2D array creation and indexing with the topic guide for 4.11. Practice writing nested loops for row-major and column-major traversal from 4.12. Then apply standard algorithms to rows, columns, and subsections as covered in 4.13. Trace code that uses arr.length and arr[0].length for loop bounds.
Trace linear search on arrays, ArrayLists, and 2D arrays. Then trace selection sort and insertion sort pass by pass on short arrays. Use the topic guides for 4.14 and 4.15 and work through practice questions that ask for the array state after a specific number of passes.
Study the recursion topic guide for 4.16 and practice tracing call stacks for factorial-style and string-processing examples. Then move to 4.17: trace binary search iterations and merge sort split-and-merge phases. Use the AP score calculator to estimate your readiness after completing practice questions across the full unit.
Open the individual guides for Unit 4 when you want a closer review of one topic.
Use AP-style practice after you review the notes so you can check what you understand.
Practice free-response reasoning and compare your answer with scoring guidance.
Open the Fiveable one-page unit review, then explore visual cheatsheets for a quick refresher.
Estimate your broader AP score goal after you review the course and exam format.
Print the unit cheatsheets ($3) or unit exams ($5) for Unit 4. Yours to keep, no subscription needed.
get printablesAP CSA Unit 4 covers 17 topics across arrays, ArrayLists, 2D arrays, and algorithms. Key topics include Array Creation and Access, Array Traversals, ArrayList Methods, ArrayList Traversals, 2D Array Creation and Access, 2D Array Traversals, Searching Algorithms, Sorting Algorithms, Recursion, and Recursive Searching and Sorting. It also covers Wrapper Classes, Using Text Files, and Ethical and Social Issues Around Data Collection. See the full topic list at /ap-comp-sci-a/unit-4.
AP CSA Unit 4 makes up 30-40% of the AP exam, making it the heaviest-weighted unit on the test. It covers arrays, ArrayLists, 2D arrays, searching and sorting algorithms, and recursion. Because so much of the exam draws from this unit, getting comfortable with these data structures and their algorithms is one of the highest-leverage things you can do.
The AP CSA Unit 4 progress check includes both MCQ and FRQ parts that test your understanding of arrays, ArrayLists, 2D arrays, searching and sorting algorithms, and recursion. The MCQ section tests topics like Array Traversals, ArrayList Methods, and 2D Array Traversals. The FRQ section asks you to write or analyze code using these data structures and algorithms, similar to what you'll see on the real AP exam. For matched practice on all 17 Unit 4 topics, visit /ap-comp-sci-a/unit-4.
AP CSA Unit 4 FRQs most often involve writing methods that use arrays, ArrayLists, 2D arrays, or recursion to solve a problem. You'll typically be asked to traverse a data structure, implement a searching or sorting algorithm, or write a recursive method. To practice, work through released College Board FRQs that focus on Array Algorithms, ArrayList Algorithms, and 2D Array Algorithms, then check your logic step by step. Find practice problems and study guides at /ap-comp-sci-a/unit-4.
You can find AP CSA Unit 4 MCQ and practice test questions at /ap-comp-sci-a/unit-4, which has resources organized by topic across all 17 Unit 4 topics. For targeted multiple-choice practice, focus on Array Traversals, ArrayList Methods, 2D Array Traversals, Searching Algorithms, Sorting Algorithms, and Recursion, since those topics show up most often on the exam.
Start with arrays before moving to ArrayLists, since ArrayLists build on the same traversal logic but add dynamic sizing. Then move to 2D arrays, which are just arrays of arrays. Once your data structure fundamentals are solid, tackle Searching Algorithms and Sorting Algorithms, then finish with Recursion and Recursive Searching and Sorting. Writing actual code for each topic, not just reading it, is the fastest way to build real understanding. - Review Array Creation and Access, then practice traversal loops. - Learn ArrayList Methods like `add`, `remove`, `get`, and `size`. - Practice 2D Array Traversals with nested loops. - Trace through linear search, binary search, selection sort, and insertion sort by hand. - Write small recursive methods and identify the base case and recursive case every time. All 17 topics with study guides are at /ap-comp-sci-a/unit-4.
public static void processList(ArrayList<Integer> data) {
int first = data.get(0);
data.add(first);
data.remove(0);
}public class Box
{
/**
* Returns the category of the box (e.g., "electronics", "clothing")
*/
public String getCategory()
{ /* implementation not shown */ }
/**
* Returns the weight of the box in kilograms
*/
public double getWeight()
{ /* implementation not shown */ }
/* There may be instance variables, constructors, and methods
that are not shown. */
}public class Warehouse
{
private Box[][] storage;
/**
* Returns the index of the row containing the maximum total weight
* of boxes belonging to the specified category.
* Returns -1 if no boxes of the specified category exist in storage.
* Preconditions: storage is not null and no elements
* of storage are null.
* storage has at least one row and at
* least one column.
*/
public int rowWithMaxWeight(String category)
{ /* to be implemented */}
/* There may be instance variables, constructors, and methods
that are not shown. */
}/**
* Returns the index of the row containing the maximum total weight
* of boxes belonging to the specified category.
* Returns -1 if no boxes of the specified category exist in storage.
* Preconditions: storage is not null and no elements
* of storage are null.
* storage has at least one row and at
* least one column.
*/
public int rowWithMaxWeight(String category)public class DailyReading
{
/**
* Returns the temperature in degrees Fahrenheit
*/
public double getTemperature()
{ /* implementation not shown */ }
/**
* Returns the wind speed in miles per hour
*/
public double getWindSpeed()
{ /* implementation not shown */ }
/**
* Returns true if rain was recorded, false otherwise
*/
public boolean isRaining()
{ /* implementation not shown */ }
/* There may be instance variables, constructors, and
methods that are not shown. */
}public class WeatherStation
{
/** The list of daily weather readings */
private ArrayList<DailyReading> readings;
/**
* Returns the average temperature of readings that meet the specified criteria.
* Precondition: minWind >= 0.0
* Postcondition: Returns the average temperature of readings where:
* - The wind speed is greater than or equal to minWind
* - AND (requireRain is false OR isRaining() is true)
* Returns 0.0 if no readings meet the criteria.
*/
public double averageTempWithCondition(boolean requireRain, double minWind)
{ /* to be implemented */ }
/* There may be instance variables, constructors, and methods
that are not shown. */
}/**
* Returns the average temperature of readings that meet the specified criteria.
* Precondition: minWind >= 0.0
* Postcondition: Returns the average temperature of readings where:
* - The wind speed is greater than or equal to minWind
* - AND (requireRain is false OR isRaining() is true)
* Returns 0.0 if no readings meet the criteria.
*/
public double averageTempWithCondition(boolean requireRain, double minWind)