AP Computer Science A
Unit 6: Arrays
7 topics to cover in this unit
Watch Video
AI-generated review video covering all topics
Watch NowStudy Notes
Follow-along note packet with fill-in-the-blank
Start NotesTake Quiz
20 AP-style questions to test your understanding
Start QuizUnit Outline
Array Creation and Access
Alright, let's kick off Unit 6 by understanding the foundational building block of data collections: the array! Think of an array like a row of mailboxes, each holding a piece of data. We'll learn how to declare these mailboxes, put data into them, and pull data out using their unique addresses (indices). This is where you learn to store multiple values of the *same type* in one neat package.
- Forgetting to use the 'new' keyword to instantiate an array (e.g., `int[] nums;` vs `int[] nums = new int[5];`).
- Confusing the array's length with the index of its last element (e.g., if length is 5, the last index is 4).
- Thinking arrays can hold different data types (they can only hold one type).
Traversing Arrays
Now that we have our mailboxes, how do we look at *every single piece* of mail inside? That's where traversing comes in! We'll use our trusty 'for' loops to systematically visit each element in an array, one by one. This is crucial for performing operations on all elements, like summing them up or finding the largest value.
- Off-by-one errors in loop conditions (e.g., using `<=` instead of `<` with `array.length`), leading to `ArrayIndexOutOfBoundsException`.
- Incorrectly starting the loop index at 1 instead of 0.
- Attempting to modify the array's size during traversal (arrays have a fixed size).
Enhanced for Loop for Arrays
Sometimes, you just want to *read* the mail, not worry about which mailbox it came from. Enter the enhanced 'for' loop, also known as the for-each loop! It's a super convenient, concise way to iterate through all elements of an array when you don't need the index. It's like magic for simple read-only traversals!
- Believing that changes made to the loop variable in an enhanced 'for' loop will modify the actual array element (this is true for objects where you modify the object's state, but not for primitive values or reassigning the loop variable itself).
- Trying to use an enhanced 'for' loop when the index is required (e.g., for swapping elements or processing adjacent elements).
Developing Algorithms Using Arrays
This is where the real fun begins! We'll take our array knowledge and combine it with loops and conditionals to build powerful algorithms. Think about finding the biggest number, the smallest, summing them all up, or even reversing the order of elements. These are classic array problems that the AP exam LOVES, so pay close attention!
- Not initializing 'min' or 'max' variables correctly (e.g., initializing 'min' to 0 instead of the first array element or a very large number).
- Failing to consider edge cases, such as an empty array or an array with only one element.
- Incorrectly swapping elements or shifting them, leading to data loss or incorrect order.
2D Array Creation and Access
Hold on to your hats, because we're going multidimensional! Imagine not just a row of mailboxes, but a whole grid of them – like a spreadsheet or a chessboard. That's a 2D array! We'll learn how to declare, instantiate, and access elements in these 'arrays of arrays' using *two* indices, one for the row and one for the column.
- Confusing row and column indices (e.g., `arr[column][row]` instead of `arr[row][column]`).
- Forgetting that `arr.length` gives the number of rows, and `arr[0].length` (or `arr[anyRow].length`) gives the number of columns in that specific row.
- Thinking all rows in a 2D array must have the same number of columns (they usually do in AP CSA, but technically Java allows 'jagged' arrays).
Traversing 2D Arrays
Okay, we've got our grid of mailboxes. Now, how do we visit *every single one*? You guessed it: nested loops! We'll use an outer loop to go through each row and an inner loop to go through each column within that row. This is your go-to strategy for processing all the data in a 2D array.
- Incorrectly using `arr.length` for the inner loop condition (it should be `arr[row].length`).
- Mixing up which loop variable corresponds to rows and which to columns.
- Off-by-one errors in the loop bounds, leading to `ArrayIndexOutOfBoundsException`.
Developing Algorithms Using 2D Arrays
Time to put it all together! Just like with 1D arrays, we'll apply our algorithmic thinking to 2D arrays. We'll learn to find sums of rows or columns, locate specific values, or even transform the entire grid. These algorithms often build upon the patterns you learned for 1D arrays, just with an extra dimension of complexity!
- Incorrectly accumulating sums or counts across rows/columns (e.g., resetting a sum variable in the wrong place).
- Struggling to adapt 1D array algorithms to a 2D context, especially when dealing with specific rows/columns.
- Misidentifying elements on diagonals or specific boundaries within the 2D array.
Key Terms
Key Concepts
- Arrays store a fixed number of elements of the same data type.
- Elements are accessed using a 0-based index, meaning the first element is at index 0 and the last is at `array.length - 1`.
- Traditional 'for' loops are used to iterate through arrays when the index is needed for access or modification.
- The loop condition typically uses `array.length` to ensure all elements are processed without going out of bounds.
- The enhanced 'for' loop provides a simpler syntax for iterating over each element in an array.
- It is primarily used for read-only access; it does not provide access to the element's index and cannot be used to modify the array elements directly (for primitive types).
- Common algorithms include finding minimum/maximum values, calculating sums/averages, searching for specific elements, and modifying array contents (e.g., shifting, reversing).
- These algorithms often involve a loop (or nested loops) and conditional statements to process and compare elements.
- 2D arrays are arrays where each element is itself an array, forming a grid-like structure.
- Elements are accessed using two 0-based indices: `[row][column]`.
- 2D arrays are typically traversed using nested 'for' loops: an outer loop for rows and an inner loop for columns.
- The outer loop iterates from `0` to `array.length - 1` (number of rows), and the inner loop iterates from `0` to `array[row].length - 1` (number of columns in the current row).
- Algorithms for 2D arrays often involve applying 1D array logic to individual rows or columns, or processing the entire grid.
- Common tasks include finding sums of rows/columns, locating specific elements, finding min/max in the entire array, or processing elements along diagonals.
Cross-Unit Connections
- **Unit 2: Using Objects:** Arrays can store objects (e.g., `String[]`, `Fraction[]`, `Student[]`), leading to arrays of references. This unit explains *how* to store them, but Unit 2 explains *what* those objects are.
- **Unit 3: Boolean Expressions and If Statements:** Conditional logic (`if/else`) is absolutely essential within array algorithms for comparisons, searching, and filtering elements.
- **Unit 4: Iteration:** Loops (for, while) are the backbone of array traversal and algorithm implementation. You simply cannot process an array without iteration!
- **Unit 5: Writing Classes:** Arrays can be used as instance variables within classes to store collections of data for an object. Methods within classes can also take arrays as parameters or return arrays.
- **Unit 7: ArrayList:** Arrays are the fixed-size, fundamental data structure that `ArrayList` builds upon. Understanding arrays is crucial for appreciating the flexibility and convenience `ArrayList` offers.
- **Unit 9: Inheritance:** Arrays can store polymorphic objects, meaning an array declared to hold objects of a superclass type can actually hold objects of any of its subclasses. This allows for powerful and flexible data storage.