One week before the AP Computer Science A exam is not the time to start new material. It's the time to sharpen what you already know, eliminate recurring mistakes, and build the confidence that comes from writing correct Java code under timed pressure. This plan tells you exactly what to do each day, in what order, and why.
The AP CS A exam is three hours and fully digital: you answer both sections, including typing your free-response code, in College Board's Bluebook app. Prepare as if you can't run your code to check it. Every point depends on what you can produce from memory under time pressure. That's what this week is designed to prepare you for.
Know the Exam Before You Study for It
The exam has two sections of equal time (this reflects the revised exam College Board introduced for the 2025–26 school year):
| Section | Format | Time | Weight |
|---|---|---|---|
| Section I | 42 multiple-choice questions | 90 minutes | 55% |
| Section II | 4 free-response questions | 90 minutes | 45% |
The MCQ section tests reading and tracing Java code. The FRQ section tests writing it. Multiple choice counts slightly more (55% vs. 45%), but neglecting either one is costly. Many students over-index on content review and under-invest in FRQ writing practice. This plan balances both.
Each of the four FRQs now has a fixed type:
| FRQ Type | What It Tests | Typical Point Value |
|---|---|---|
| 1. Methods and Control Structures | Writing methods with loops and conditionals; Part B requires calling String methods | 9 points |
| 2. Class Design | Writing a complete class: header, instance variables, constructor, and a method | 9 points |
| 3. Data Analysis with ArrayList | Using, analyzing, and changing data in an ArrayList | 9 points |
| 4. 2D Array | Row/column traversal and algorithms on a 2D array | 9 points |
The 7-Day Plan
Each day runs 60 to 90 minutes. The first four days are topic-focused review and practice. Days 5 and 6 are pure exam simulation. Day 7 is targeted cleanup. Adjust the days to match when your exam actually falls.
Day 1: Java Fundamentals and Control Flow
These are the building blocks everything else depends on. Class design and data collections both rely on correct loop and conditional logic, so any gaps here compound across the whole exam.
Review (20 minutes): primitives (int, double, boolean), integer division and casting, the modulo operator, String methods (length(), substring(), indexOf(), equals(), compareTo()), for loops, while loops, and nested loops.
Practice (45 minutes): trace 5 loop problems by hand with a variable table. Then write 3 methods from scratch: one that uses a loop to accumulate a sum, one that uses a conditional to classify a value, and one that manipulates a String using substring() and indexOf(). Write them without an IDE: a plain text editor with no autocomplete.
Key concepts to confirm you know cold:
- Integer division truncates.
7 / 2is3, not3.5. To get3.5, cast first:(double) 7 / 2. - Modulo gives the remainder.
13 % 5is3. Use it to check even/odd (n % 2 == 0), extract the last digit (n % 10), or cycle through a range. - Never use
==to compare Strings. Use.equals()for content equality.==checks object identity, not value. substring(a, b)returns characters from index a up to but not including b."computer".substring(3, 6)returns"put"(indices 3, 4, 5).- Loop bounds:
i < arr.length, noti <= arr.length. The last valid index isarr.length - 1.
Day 2: Class Design
Class Design is always FRQ 2, and classes appear throughout the MCQ section too. This day covers everything you need to write and reason about Java classes confidently. Designing inheritance hierarchies is no longer tested, so don't spend time on extends, super(), or polymorphism.
Review (20 minutes): class structure (header, instance variables, constructors, methods), private vs. public, the this keyword, static vs. instance variables and methods, and variable scope.
Practice (45 minutes): write a complete class from scratch without an IDE: the class header, private instance variables, a constructor, and at least two methods. Time yourself; aim for under 15 minutes. Then add a static variable that counts how many objects have been created. Finally, trace 3 MCQ-style problems on scope and this: given a parameter with the same name as an instance variable, determine which one each line changes.
Key concepts to confirm you know cold:
- Constructors have no return type, not even
void.public void Student()is a regular method, not a constructor. - A
staticvariable is shared by every object of the class. Changing it through one object changes it for all of them. Instance variables belong to each object separately. - A parameter with the same name as an instance variable hides it. Inside the constructor,
name = name;does nothing useful. Writethis.name = name;to set the instance variable. - Overloading: two methods or constructors in the same class can share a name if their parameter lists differ.
- Instance variables should be
private. Graders on the real exam expect this. Public instance variables lose the encapsulation point.
Day 3: Arrays and ArrayLists
Arrays and ArrayLists appear in at least one dedicated FRQ every year, and array traversal is the backbone of many MCQ problems. This day focuses on execution accuracy: writing the correct syntax, avoiding the common bugs, and handling both data structures fluently.
Review (20 minutes): 1D array declaration and initialization, arr.length (property, no parentheses), standard and enhanced for loops, ArrayList methods (add, get, set, remove, size()), and removing elements during traversal.
Practice (45 minutes): write these four methods without an IDE.
- Find and return the index of the minimum value in an
int[]. - Return a new
int[]containing only the positive values from a givenint[]. - Remove all elements less than a given threshold from an
ArrayList<Integer>in place. - Return the number of elements in an
ArrayList<String>whose length exceeds a given value.
Key concepts to confirm you know cold:
- Arrays use
arr.length(no parentheses). ArrayLists uselist.size()(with parentheses). Mixing these up is a compile error. - Enhanced for loops cannot modify array elements.
for (int val : arr) { val = 0; }does nothing to the array. Use a standard indexed loop to write values. - Removing from an ArrayList during a forward loop skips elements. After
list.remove(i), the element ati+1shifts toi. Theni++skips it. Fix: iterate backwards or decrementiafter each removal. - Use
.equals(), not==, to compareIntegerorStringobjects in an ArrayList. - The two-pass pattern for building a new array: first count how many elements meet the condition, then allocate an array of that size, then fill it in a second pass.
Day 4: 2D Arrays, Text Files, and Tracing Recursion
These topics appear together here because they're often where students feel least confident. All of them reward practice more than re-reading notes. Note that you only need to trace recursion now; writing recursive methods is no longer tested.
Review (20 minutes): 2D array declaration, arr.length for rows, arr[0].length for columns, row-major and column-major traversal. Then: reading a text file with Scanner and File, and how to trace a recursive call stack.
Practice (45 minutes): work these problems without an IDE.
- Write a method that returns the sum of all elements in a 2D
intarray. - Write a method that returns the largest value in a specific column of a 2D array.
- Trace
mystery(5)for this method:
Draw the full call stack, then identify what the method computes.public static int mystery(int n) { if (n == 0) return 0; return n + mystery(n - 1); } - Write code that reads every line of a text file named
scores.txtand returns how many lines contain the word"pass".
Key concepts to confirm you know cold:
matrix.lengthis the number of rows.matrix[0].lengthis the number of columns. These are not interchangeable. Using the wrong one causesArrayIndexOutOfBoundsException.- Row-major traversal: outer loop over rows, inner loop over columns. Column-major: swap the loop order. The inner variable changes fastest.
- Reading a file:
Scanner sc = new Scanner(new File("scores.txt"));then loopwhile (sc.hasNextLine())and callsc.nextLine(). A method that opens a file must declarethrows IOException. - Every recursive method has a base case. It's the call that returns without calling itself again. Find it first when you trace.
- Trace recursion with a call stack diagram. Write each call on a new indented line, mark the base case when it's reached, then unwind upward, substituting return values.
- The number of recursive calls is not the same as the return value. Exam questions ask both; know which question is being asked before you answer.
Day 5: FRQ Writing Practice, All Four Types
Content review ends today. From here, every session is about execution: writing correct Java without an IDE under time pressure.
Session structure (90 minutes total): write one FRQ of each type, 20 minutes each, with 10 minutes at the end to review your work. Use released FRQs from the College Board's AP CS A free-response archive at apcentral.collegeboard.org. Older exams include inheritance and recursion-writing questions that are no longer tested; skip those.
| FRQ | Time | Focus While Writing |
|---|---|---|
| Methods and Control Structures | 20 min | Method signature matches exactly; return vs. print; loop bounds correct |
| Class Design | 20 min | No return type on constructor; instance variables private; all methods requested are present |
| Data Analysis with ArrayList | 20 min | size() and get() syntax; removing while traversing; enhanced vs. indexed loop |
| 2D Arrays | 20 min | Row vs. column dimension; correct loop nesting order |
After writing each FRQ, score it against the official rubric. For every point you missed, write down the specific reason: wrong syntax, wrong logic, wrong method signature, missing edge case. Keep a running list of your most common errors across all four FRQs.
Day 6: Full Mock Exam Under Timed Conditions
This is the most important day of the week. Simulate the real exam as closely as possible.
Section I (90 minutes): 42 MCQ, no breaks, no looking anything up. Use official College Board practice MCQs, ideally a Bluebook test preview so you get used to the digital format.
10-minute break.
Section II (90 minutes): 4 FRQs, typed without an IDE. Choose a full set of past FRQs from a single year's exam so the difficulty level is consistent.
After finishing, record your results:
- MCQ: how many correct out of 42?
- FRQ: estimate points earned on each question using the scoring rubric.
- Time: did you finish both sections? If not, which question types ran long?
Don't review your mistakes today. Save that for Day 7. Rest after the mock exam.
Day 7: Targeted Cleanup
Don't start new material. Use everything Day 6 revealed.
First 45 minutes: go through every wrong MCQ answer and every point deducted on FRQs. For each mistake, categorize it:
- Syntax error (wrong method name, missing semicolon, wrong operator): type the correct version three times without autocomplete to build muscle memory.
- Logic error (wrong loop bound, wrong condition, off-by-one): trace through what your code actually did versus what the problem required. Identify where the reasoning broke down.
- Concept gap (mixed up static and instance variables, confused
lengthwithsize()): spend 10 focused minutes on that concept, then do 2 to 3 practice problems on it. - Time management (didn't finish): practice the two-pass MCQ strategy and the 20-minute-per-FRQ discipline. Spending 40 minutes on one FRQ and rushing the other three is a common and avoidable mistake.
Final 20 minutes: skim the quick-reference table below. Cover each row and try to recall it before looking. If any row gives you trouble, spend the remaining time on it. Then stop. More review past this point adds anxiety, not knowledge.
Java Quick Reference: What You Must Know Without Looking
| Topic | What to Know |
|---|---|
| Integer division | 7 / 2 = 3. Cast to double for decimals: (double) 7 / 2 = 3.5 |
| Modulo | 13 % 5 = 3. Even: n % 2 == 0. Last digit: n % 10 |
| String comparison | Use .equals(), never == |
| String methods | s.length(), s.substring(a,b) (b exclusive), s.indexOf(str), s.charAt(i) |
| Array length | arr.length (property, no parentheses). Last index: arr.length - 1 |
| ArrayList size | list.size() (method, with parentheses) |
| ArrayList methods | add(val), add(i, val), get(i), set(i, val), remove(i) |
| 2D array dimensions | arr.length = rows. arr[0].length = columns |
| Constructor syntax | No return type (not even void). Same name as the class. |
| Static vs. instance | static variables are shared by all objects; instance variables belong to each object |
| Reading a text file | new Scanner(new File(name)), hasNextLine(), nextLine(); declare throws IOException |
| Recursion (tracing) | Find the base case first, then unwind the call stack. You won't have to write recursive code. |
The Highest-Value FRQ Habits
These are the habits that protect points on FRQs. Each one addresses a mistake that appears on the rubrics of graded exams year after year.
- Copy the method signature exactly. If the FRQ specifies
public int getTotal(int[] values), write that exactly. Changing the parameter type, return type, or method name forfeits the signature point immediately. - Return values; don't print them.
return result;andSystem.out.println(result);are not interchangeable. When the FRQ asks for a method that returns something, usereturn. - Use helper methods when they're given to you. FRQs frequently tell you that the class has certain methods already. Call them; don't rewrite them. Rewriting wastes time and introduces errors.
- Write something for every part. FRQ parts are scored independently. A completely wrong part (a) doesn't prevent you from earning full credit on part (b). Leaving a part blank guarantees zero; writing something earns at least a chance at partial credit.
- Check semicolons and braces before moving on. A missing closing brace makes your entire method unreadable to the grader. Spend 30 seconds scanning before moving to the next part.
- Don't delete working code before its replacement is finished. Responses are submitted automatically when time runs out, and readers score what's in the box. If you start a rewrite, keep your first version until the new one is complete.
MCQ Strategy for the Final Week
MCQ questions on AP CS A fall into a few recurring types. Knowing the type before you start answering is faster than figuring it out mid-question.
| Question Type | Strategy |
|---|---|
| What does this code print? | Make a variable table. Trace one line at a time. Don't shortcut. |
| Which code segment produces the same result? | Trace both segments with a simple test case. If they differ for that case, they're not equivalent. |
| Which of the following will cause a compile error? | Check types, method signatures, and syntax. Compile errors are about structure, not runtime behavior. |
| Which of the following will cause a runtime error? | Look for ArrayIndexOutOfBoundsException, NullPointerException, and infinite loops. These require execution to trigger. |
| What is the value of [variable] after this code runs? | Trace carefully, especially around loop exits and conditional branches. |
Two-pass strategy for the MCQ section: in the first pass (about 55 minutes), answer every question you can handle in under 90 seconds. Skip any question that requires long tracing or that you're genuinely unsure about; mark it and move on. In the second pass, work through the skipped questions with full attention. In the final 5 minutes, confirm nothing is blank. There is no penalty for wrong answers.
What Not to Do This Week
- Don't practice exclusively in an IDE. You type your answers in Bluebook, not the editor you use in class. Code written in an IDE looks correct because the IDE catches errors and fills in syntax for you. Practice every day with autocomplete off and without running your code first.
- Don't spend the final two days reading notes. After Day 4, every session should involve writing code or tracing problems. Passive review at this stage gives the feeling of progress without the substance.
- Don't skip the mock exam. Students who do a full timed mock exam before the real one consistently outperform those who don't. The simulation effect is real: you perform better at something you've already done once under pressure.
- Don't try to memorize the entire Java API. AP CS A tests a specific subset of Java. The exam provides a quick reference for the methods you need. Focus on understanding how to use what's in scope, not memorizing edge cases of methods that won't appear.
- Don't cram the night before. Review for 20 to 30 minutes maximum, then stop. Sleep is the single most effective performance enhancer available to you the night before an exam.
Exam Day Protocol
The night before: skim the quick-reference table above one final time. Pack everything you need: your student ID, a pencil for scratch work, and, if your school has you bring your own device, a fully charged laptop with Bluebook installed and its exam setup completed. Eat dinner. Sleep by 10 p.m.
The day of: AP CS A is an afternoon exam, so eat a real breakfast and lunch. Arrive early. Don't study in the car or in line; it adds stress without adding knowledge at this point.
During Section I (MCQ): use the two-pass strategy. If a tracing problem looks complex, skip it and come back. Keep moving.
During Section II (FRQ): spend no more than 22 minutes on any single question. If you're stuck on part (c) of a question and you've already spent 20 minutes on parts (a) and (b), move on and come back if time allows. Blank parts earn zero; a partial attempt earns something.
On every FRQ: read the entire question before writing anything. Note what each part is asking. Note what data structures and methods the question tells you already exist; use them rather than rewriting them.
One Week Is Enough
Students who practice writing code without an IDE every day, simulate exam conditions before the real thing, and spend the final week on execution rather than new content see consistent score improvements. The exam is demanding but predictable. The plan above gives you the structure to make the most of the time you have.
If you want expert guidance through the final stretch, ExamReadyUSA's AP CS A Crash Course includes a dedicated final-week session with graded FRQ practice and line-by-line feedback from Namrata Poladia, a College Board AP Reader who scores real AP CS A exams. Groups are capped at 5 students so every question gets a thorough answer.