AP Computer Science A — Cheatsheet

Formulas & relationships

On the exam

• On the exam, `new` always appears with a class that has a matching constructor. If the arguments do not match any constructor’s parameter list, the code fails to compile — check the number and types of arguments carefully.
• When you see chained calls, rewrite them as separate steps on scratch paper: compute the leftmost call, replace it with its result, and repeat. This prevents mis-reading `s.trim().length()` as calling `length()` on the original spaced string.
• For any `indexOf` or `substring` question, write the string out and label each character with its index starting at 0. Counting on paper prevents off-by-one mistakes with the excluded end index.
• `Math` methods are static: always call them as `Math.name(...)`, never on an object. And watch the return type — `Math.pow` returns a `double`, so `Math.pow(2, 3)` is `8.0`, not `8`.
• The idiom `x % 2 == 0` tests for even; `x % 2 != 0` (or `== 1` for positive x) tests for odd. Expect this pattern in tracing questions and in FRQ logic.
• To trace a loop, make a small table with a column per variable and one row per pass. Writing the value after each iteration prevents off-by-one errors on the final count.
• When the inner bound is the outer variable (`j <= i`), do not multiply — add the per-row counts. A triangular pattern like 1 + 2 + 3 is the tell.
• For swap questions, resist the urge to assume a = b overwrites both. Trace all three statements: the temporary variable is what makes the exchange work correctly.
• Track an object’s state across a sequence of calls by keeping a running note of each instance variable. Mutator calls change it; accessor calls only read it.
• Remember the split: **instance** variables default (int → 0, boolean → false, object → null), but **local** variables must be initialized before use or the code will not compile.
• On the exam, directly reading or writing a `private` field from outside its class is always an error. Legal access outside the class must go through a `public` method.
• **None of this is on the current exam.** The 2025 redesign of AP Computer Science A removed inheritance, polymorphism, `extends`, `super` and interfaces from the course. If you are revising for the exam, skip this lesson — Unit 3 is now tested on writing classes, instance variables, `this`, encapsulation, and static members and scope. This is here because inheritance is real Java that you will meet the moment you write code outside this course, and it costs you nothing to read once the exam is over.
• A subclass inherits public methods but not private fields directly — it reaches them through inherited methods or by passing values up with `super(...)`. `super(...)` must be the first line of the subclass constructor.
• An index runs from 0 to `length - 1`. To loop over every element, use `for (int i = 0; i < arr.length; i++)` — note the strict `<`, which stops correctly at the last valid index.
• When removing elements in a loop, remember each `remove(i)` shifts later elements left. Iterating forward with a normal index can skip elements — a very common FRQ trap.
• To traverse a full grid, use `for (int r = 0; r < m.length; r++)` outside and `for (int c = 0; c < m[0].length; c++)` inside. The outer loop walks rows, the inner walks columns.
• Seed a max/min search with `a[0]` and start the loop at index 1. Seeding with 0 can be wrong for arrays of all-negative numbers, and forgetting to update `max` leaves it stuck at the first value.

How to get a 5

• When removing elements from an ArrayList inside a standard for loop, iterate backward (from size()-1 down to 0) to avoid skipping elements as indices shift.
• On the free response, write clear, simple logic. You do not get extra points for "clever" or highly optimized code, but you do lose points for logic errors.
• Pay close attention to boundary conditions in arrays. The valid indices are 0 to arr.length - 1. A loop condition like i <= arr.length will cause an Exception.
• Remember that Strings are immutable. Methods like substring() or toUpperCase() return a *new* String; they do not change the original.
• Budget your time by section: the multiple-choice half is 40 questions in 90 minutes, so a code-trace item you cannot resolve in about two minutes should be marked and revisited, and the free-response half gives you roughly 22 minutes per question — enough to trace your own method on paper before you move on.
• Trace with a table, not in your head. Write one column per variable and one row per loop iteration; most missed multiple-choice points are off-by-one loop bounds or a variable updated in the wrong order, and both become obvious on paper.
• Check every division for the integer-division trap. If both operands are int, the result truncates. When a method returns a double, force double arithmetic by using a literal such as 100.0 or an explicit (double) cast, and say so in your answer.
• Honor the interface the problem hands you. Copy the method signatures exactly — the stated return type, parameter order, and access modifier — respect the given preconditions, and call any helper the prompt supplies or asks you to write, since calling it is usually worth a rubric point while re-implementing its logic risks that point and adds new bugs. Restate the postcondition in your own words before writing a line, because code that solves a different problem than the one specified earns nothing.
• You are not penalized for extra correct code, so never leave a part blank. Partial credit is awarded per rubric line, so an attempt that declares the variables, sets up the traversal, and returns something plausible often scores 2 or 3 of 4 points.
• Write the loop header and the return statement before the body, then handle the boundary cases graders always test: an empty array or list, a single element, the first and last index, and a search value that is not found. This guarantees a bound tied to length or size() and a correct return type on every path.

Key terms