AP CS A Final Week Study Plan: The Ultimate Revision Guide

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 entirely on paper. There's no compiler, no autocomplete, and no ability to run your code and check. 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:

The MCQ section tests reading and tracing Java code. The FRQ section tests writing it. Both halves count equally, so neglecting either one is costly. Many students over-index on content review and under-invest in FRQ writing practice. This plan balances both.

The four FRQ types rotate but the topics are consistent:

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. Even advanced topics like recursion and inheritance 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 on paper, not in an IDE.

Key concepts to confirm you know cold:

• Integer division truncates. 7 / 2 is 3, not 3.5. To get 3.5, cast first: (double) 7 / 2.
• Modulo gives the remainder. 13 % 5 is 3. 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, not i <= arr.length. The last valid index is arr.length - 1.

Day 2: Classes, Inheritance, and Polymorphism

The Classes FRQ appears every year. OOP concepts also appear heavily in the MCQ section. This day covers everything you need to write and reason about Java classes confidently.

Review (20 minutes): class structure (instance variables, constructors, methods), private vs. public, this keyword, static vs. instance members, toString(), inheritance (extends, super()), method overriding, and polymorphism.

Practice (45 minutes): write a complete class from scratch on paper: instance variables, a constructor, at least two methods, and a toString(). Time yourself; aim for under 15 minutes. Then write a subclass that extends it, overrides one method, and adds one new method. Finally, trace 3 polymorphism MCQ-style problems: given a superclass reference holding a subclass object, determine which method version runs.

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.
• super() must be the first statement in a subclass constructor. Placing it anywhere else is a compile error.
• Overriding vs. overloading: overriding replaces a superclass method with the same signature in a subclass. Overloading creates multiple methods with the same name but different parameters in the same class.
• Polymorphism: the declared type determines which methods are accessible at compile time. The actual object type determines which version runs at runtime. Animal a = new Dog(): you can only call methods declared in Animal, but if Dog overrides speak(), Dog's version runs.
• 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 by hand on paper.

1. Find and return the index of the minimum value in an int[].
2. Return a new int[] containing only the positive values from a given int[].
3. Remove all elements less than a given threshold from an ArrayList<Integer> in place.
4. 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 use list.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 at i+1 shifts to i. Then i++ skips it. Fix: iterate backwards or decrement i after each removal.
• Use .equals(), not ==, to compare Integer or String objects 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 and Recursion

These two topics appear together here because they're often where students feel least confident. Both reward practice more than re-reading notes.

Review (20 minutes): 2D array declaration, arr.length for rows, arr[0].length for columns, row-major and column-major traversal. Then: recursion base case and recursive case, how to trace a call stack, and the "trust the recursion" mindset for writing recursive methods.

Practice (45 minutes): write these problems by hand.

1. Write a method that returns the sum of all elements in a 2D int array.
2. Write a method that returns the largest value in a specific column of a 2D array.
3. Trace mystery(5) for this method:

   public static int mystery(int n) {
       if (n == 0) return 0;
       return n + mystery(n - 1);
   }

   Draw the full call stack, then identify what the method computes.
4. Write a recursive method countDown(int n) that prints the integers from n down to 1, each on its own line, without using a loop.

Key concepts to confirm you know cold:

• matrix.length is the number of rows. matrix[0].length is the number of columns. These are not interchangeable. Using the wrong one causes ArrayIndexOutOfBoundsException.
• Row-major traversal: outer loop over rows, inner loop over columns. Column-major: swap the loop order. The inner variable changes fastest.
• Every recursive method needs a base case. Without one, you get a StackOverflowError at runtime. Always identify the base case before writing the recursive case.
• 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 on paper 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.

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): 40 MCQ, no breaks, no looking anything up. Use official College Board practice MCQs.

10-minute break.

Section II (90 minutes): 4 FRQs, writing on paper. 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 40?
• 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): write the correct version three times by hand 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 (didn't know how polymorphism worked, confused length with size()): 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

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; and System.out.println(result); are not interchangeable. When the FRQ asks for a method that returns something, use return.
• 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 cross out more than you intend to. Graders score what's on the page. If you cross out a correct line while fixing something else, that point is gone.

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.

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. The exam is on paper. Code written in an IDE looks correct because the IDE catches errors. Code written by hand shows your actual knowledge. Practice on paper every day.
• 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: pencils, your student ID, a watch if you want to track time. Eat dinner. Sleep by 10 p.m.

The morning of: eat a real breakfast. 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. Underline 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 by hand 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.