AP Computer Science A Study Guide
Eight units covering all 34 AP CSA topics, each linked to its own practice set. Each unit explains what to know, how to apply it, what typically goes wrong, and one study move that makes the material stick.
Language
Java. The exam uses a documented subset, so unfamiliar library methods are supplied in the reference rather than assumed.
Exam shape
Two sections: 40 multiple-choice questions, then 4 free-response questions that are written by hand in Java.
No calculator
None is permitted or needed. The arithmetic is deliberately small so that reasoning, not computation, is what is tested.
Where it leads
A first university programming course, and the prerequisite habits for data structures and algorithms.
Units
Unit 1 is the largest by a wide margin. The rest move faster, and the last one is the bridge into calculus.
Unit 1 · Foundational
The arithmetic layer everything else sits on. Most of this unit is one rule with wide consequences: Java decides the type of an expression before it decides the value, and integer division discards the remainder rather than rounding.
Unit 2 · Foundational
Where a program starts making choices. The unit covers building boolean expressions, ordering branches so they do not overlap, and the short-circuit behavior that lets a condition guard itself against its own errors.
Unit 3 · Heavy
Repetition, and the accounting that makes it correct. The unit is less about loop syntax than about knowing what each variable means after one pass, which is the only reliable way to get bounds and accumulators right.
Unit 4 · Moderate
Text as an immutable object. Two facts generate most of the unit: indexing starts at zero and stops one before the length, and no String method ever changes the String it was called on.
Unit 5 · Heavy
Fixed-size indexed storage, and the first place two variable names can refer to the same data. Aliasing is what makes array questions harder than they look.
Unit 6 · Heavy
A resizable list of objects. The unit adds one genuinely tricky behavior: removing during a traversal shifts every later element, so the loop and the list disagree about where things are.
Unit 7 · Heavy
Where the free-response section lives. The unit covers writing a method to a specification and designing a class that protects its own state, which together account for most FRQ credit.
Unit 8 · Exam-weighted
The final unit combines grid traversal, the standard search and sort algorithms with their efficiency comparison, and the data topics that close the course.
Mathematical Practices
Four habits that decide multiple-choice accuracy and free-response credit. They run through every unit rather than being taught once and set aside.
Write the value of each variable before the line, after the line, and after the loop finishes. Almost every wrong multiple-choice answer is reachable by reasoning about what the code was meant to do rather than what it does.
The first index, the last index, the empty case, and the exact threshold are where AP CSA questions live. A method that works on a three-element example proves very little.
When code almost works, check the Java rule first: integer division, aliasing, off-by-one bounds, or the wrong comparison operator. Rewriting the algorithm when the bug is a type rule wastes the most time.
Before writing a free-response method, state its parameters, its return type, and what it must leave unchanged. Most lost FRQ points come from returning the wrong thing or mutating something that should have been left alone.
Assessment
Two lists: one for selected-response work, one for anything you have to write out.
Study plan
Four moves, in the order that pays off.
Trace short snippets daily until writing a variable table is automatic. This single habit lifts multiple-choice accuracy more than any amount of re-reading.
Integer division and modulus appear across every unit and are the most consistently missed rule in the course. Practise until the type of every expression is obvious at a glance.
For every structure you meet, know its first valid index, its last valid index, and what happens when it is empty. That is where questions are set.
The free-response section is handwritten. Practise on paper, because an IDE hides exactly the syntax errors the exam will expose.
Much of the exam is comprehension of code you did not write. Practise completing partially written classes rather than only starting from scratch.
Late revision should draw questions from across the course at random. Practising one unit at a time hides the difficulty of recognising which idea applies.
Curriculum scope
The course is organised around one skill practised at increasing scale: predict exactly what Java will do, then write code that does what you intended. Every unit adds state that has to be tracked, from a single primitive to an array of objects.
Essential foundations
Included in this sequence
Compare with the school syllabus
Glossary
Primitive type
A value type such as int, double, boolean, or char, stored directly rather than as a reference.
Integer division
Division of two ints, which discards the fractional part rather than rounding.
Cast
An explicit conversion that changes how a value is interpreted.
Short-circuit evaluation
Stopping evaluation of a compound condition as soon as the result is determined.
Accumulator
A variable carrying a running result across the iterations of a loop.
Immutability
The property that an object cannot be changed after creation, as with String.
Aliasing
Two variables referring to the same object, so a change through one is visible through the other.
Pass by value
Java parameter passing: the method receives a copy of the value, which for an object is a copy of the reference.
Encapsulation
Keeping fields private and exposing behavior through methods, so an object controls its own state.
Row-major traversal
Visiting a 2D array one full row at a time, with the row loop outside the column loop.
Precondition
A condition that must hold before an algorithm runs, such as sorted input for binary search.
Sentinel
A reserved return value, such as negative one, signalling that nothing was found.
