Free study guide — no login required
AP Computer Science A Study Guide (2026)
Last reviewed: 2026-06-10
AP Computer Science A is the College Board's introductory programming course, taught entirely in Java and equivalent to a first-semester college CS course. Over a year you go from declaring variables to designing your own classes, writing algorithms over arrays and ArrayLists, and reasoning precisely about how code behaves — skills assessed through a two-section exam that asks you to both read code (multiple choice) and write it (free response). Unlike AP Computer Science Principles, which surveys computing broadly, CSA is a depth course: one language, real syntax, real debugging.
The course was substantially revised for the 2025-26 school year. The College Board consolidated the old ten-unit framework into four bigger units — Using Objects and Methods, Selection and Iteration, Class Creation, and Data Collections — and removed inheritance, polymorphism, and recursion from the exam. This guide covers all six units in our course sequence, including Inheritance and Recursion as enrichment units, with clear notes on what the current exam does and does not test. The exam itself is now digital, administered in the Bluebook app, with the Java Quick Reference available throughout.
Use this guide as your roadmap: each unit section below explains what the unit covers, how heavily the exam weights it, and the specific skills questions are built on. The biggest strategic takeaway is visible in the weightings alone — Selection and Iteration plus Data Collections account for well over half the exam, and three of the four free-response questions draw on loops, arrays, and ArrayLists. Plan your study time accordingly.
AP Computer Science A Exam Format
The AP Computer Science A exam is 3 hrs 15 min long and has 3 sections:
| Section | Format |
|---|---|
| Section I-A | 30 MCQs, no calculator (60 min) |
| Section I-B | 15 MCQs, calculator (45 min) |
| Section II | 6 FRQs (90 min) |
The exam has two 90-minute sections, combined into a composite that is converted to the 1-5 scale. Section I is multiple choice, focused on reading code: tracing loops, evaluating expressions, and predicting output. Section II is four free-response questions in fixed, predictable categories — Methods and Control Structures, Class design, Array/ArrayList, and 2D Array — where you write Java methods or full classes to a specification. The exam is digital in Bluebook, and the Java Quick Reference (a list of provided classes and methods) is available the whole time, so never waste energy memorizing API signatures it already includes.
FRQs are graded on rubrics that award points for specific behaviors: a correct loop over the right bounds, a properly declared class header, calling a method from the prompt correctly. That means partial credit is everywhere — attempt every part, even if an earlier part stumped you, because parts are scored independently. On multiple choice there is no guessing penalty, so answer everything. Train for the clock: many students know the material but run out of time on the 2D Array question, which sits last. Practice writing complete methods in under 20 minutes each.
Who Should Take AP Computer Science A?
Take AP Computer Science A if you're considering computer science, software engineering, data science, or any engineering major — it is the strongest signal on a high school transcript that you can actually program. Many colleges award credit or placement for a 4 or 5, typically letting you skip the first programming course (often called CS1) and start in data structures. No prior coding experience is required; the course assumes only comfort with algebra-level math and builds Java from zero. The difficulty is real but specific: the challenge is precision, not abstraction. Students who practice writing and tracing code daily do well; students who only read about code struggle on the free-response section.
AP Computer Science A Units: What to Study
Unit 1: Using Objects and Methods
15-25% of examEverything in Java starts here: declaring variables with primitive types (int, double, boolean), evaluating arithmetic expressions, and understanding why 7 / 2 is 3 but 7 % 2 is 1. You learn what objects are, how constructors and the new keyword create them, and how to call methods — void versus non-void, static versus instance — while passing arguments correctly. The String and Math classes get heavy emphasis: substring and indexOf behavior, zero-based indexing, and building random-number ranges with Math.random(). On the exam, this unit shows up as expression-evaluation MCQs, casting and rounding questions, and substring traps where an off-by-one index throws an exception. Fluency here is non-negotiable, because every later free-response question assumes you can call methods and manipulate Strings without thinking.
Key topics
- Primitive types: int, double, boolean
- Integer division and modulus
- Casting and rounding
- Constructors and the new keyword
- Method calls, parameters, return values
- String methods: substring, indexOf, length
- Math class and Math.random ranges
Unit 2: Selection and Iteration
25-35% of examThis is the largest skills jump in the course: making programs decide and repeat. You write boolean expressions with relational and logical operators, simplify them using De Morgan's laws, and learn how short-circuit evaluation prevents errors like dividing by zero. Selection covers if, else if, else, and nested conditionals; iteration covers while loops, for loops, and nested loops, including classic String-traversal algorithms such as counting characters, reversing, and finding substrings. The CED also expects informal run-time analysis — counting how many times a statement executes. Exam questions lean hard on tracing: given a nested loop, what prints? Expect equivalent-boolean-expression MCQs and FRQ subparts that require building a loop with correct bounds. Off-by-one errors are the single most common point-loser, so practice tracing on paper until loop boundaries feel automatic.
Key topics
- Boolean expressions and De Morgan's laws
- if, else if, else selection
- while and for loops
- Nested loop tracing
- String traversal algorithms
- Short-circuit evaluation
- Off-by-one errors
- Statement execution counts
Unit 3: Class Creation
10-18% of examNow you write classes from scratch instead of just using them. The unit covers declaring private instance variables, writing constructors that initialize state from parameters, and building accessor (getter) and mutator (setter) methods, plus toString for readable output. You distinguish static variables and methods, which belong to the class, from instance members, which belong to each object, and use the this keyword to resolve naming collisions. Scope rules — local versus instance variables — and encapsulation as a design principle round out the unit. This material maps directly to the Class FRQ, where the rubric awards points for a correct class header, properly declared private fields, a working constructor, and method implementations that match the specification. Memorize the anatomy of a well-formed class; the rubric rewards structure as much as logic.
Key topics
- Private instance variables and encapsulation
- Writing constructors
- Accessor and mutator methods
- static variables and methods
- this keyword
- Local scope vs instance scope
- Writing toString
Unit 4: Data Collections
30-40% of examThe heavyweight of the course at 30-40% of the exam — and the source of two of the four FRQs (Array/ArrayList and 2D Array). You create and traverse 1D arrays, master the ArrayList API (add, get, set, remove, size) and its pitfalls, like skipping elements when removing during a forward traversal, and work with 2D arrays using nested loops in row-major order. Standard algorithms are the core skill set: finding a max or min, summing and averaging, counting matches, searching with sequential search, and sorting with selection sort and insertion sort. Enhanced for loops appear constantly, along with knowing when they cannot be used — modifying elements or needing indexes. If you can only over-invest in one unit, make it this one; every practice exam should include array and ArrayList writing under time pressure.
Key topics
- 1D array creation and traversal
- ArrayList: add, get, set, remove, size
- 2D arrays and nested loops
- Enhanced for (for-each) loops
- Standard algorithms: max, sum, count
- Sequential search
- Selection sort and insertion sort
Unit 5: Inheritance
Inheritance lets one class extend another, reusing and specializing its behavior: subclasses call super to run a parent constructor, override methods to change behavior, and participate in polymorphism, where the runtime type of an object — not the reference type — determines which overridden method executes. You also meet the Object class at the top of every hierarchy and its equals and toString methods. Important exam note: the revised CED that took effect in fall 2025 removed inheritance and polymorphism from the AP exam itself, so current test-takers will not see it on exam day. It remains in this guide because most classrooms still teach it, older released exams test it heavily, and it is foundational for the college CS courses this class is meant to prepare you for.
Key topics
- extends and subclasses
- super constructor calls
- Method overriding vs overloading
- Polymorphism and dynamic binding
- Object class: equals, toString
- Reference type vs runtime type
Unit 6: Recursion
Recursion is a method calling itself, and mastering it means thinking in two parts: a base case that stops the calls and a recursive case that shrinks the problem. The classic skills are tracing — predicting output by tracking the call stack as frames open and close — and recognizing recursive patterns in String and array processing. Binary search and merge sort, the two named recursive algorithms from the previous framework, show why recursion matters: both cut work dramatically compared to their linear counterparts. Like inheritance, recursion was removed from the exam in the 2025-26 CED revision, so it cannot appear on the current test. Study it anyway if you have time: it dominates early college CS assessments and technical interviews, and tracing recursive calls sharpens the same mental-execution skills the exam does reward.
Key topics
- Base case and recursive case
- Tracing recursive calls
- Call stack mechanics
- Recursive binary search
- Merge sort
- Recursion vs iteration trade-offs
How to Study for AP Computer Science A
Study the units in order — the course is strictly cumulative. Spend your first block making Units 1 and 2 automatic: you should be able to trace a nested loop or evaluate a compound boolean without hesitation, because every later question assumes it. Then give Unit 4 the largest share of your calendar; at 30-40% of the exam plus two dedicated FRQs, arrays and ArrayLists pay the highest return per hour of any topic. Critically, study by writing code — typed or on paper — not by rereading notes. Passive review feels productive and transfers almost nothing to the free-response section.
Build retrieval practice into every session: close your notes and reconstruct the ArrayList method signatures, write a selection sort from memory, or trace a loop and check yourself against the actual output. Spaced repetition makes this stick — the SM-2 algorithm schedules each concept right before you would forget it, so misses on integer division or substring bounds resurface until they are permanent. MaxYourScore's 20-question unit quizzes feed an SM-2 review queue automatically, but you can replicate the idea with flashcards: rate each recall, and review hard items sooner. Interleave topics too — mix array, ArrayList, and 2D problems in one session rather than blocking by type.
Start dedicated exam review eight to ten weeks before test day. Weeks one through six: one unit-focused week at a time, plus one timed FRQ per week scored against the actual College Board rubric so you learn exactly how points are awarded. Weeks seven and eight: full-length practice exams under exam conditions, typed, with only the Java Quick Reference open. In the final week, stop learning new material; redo your missed-question pile, reread your own FRQ errors, and drill the two or three rubric points you drop most often. Most score gains in the last month come from eliminating repeat mistakes, not from new content.
AP Computer Science A FAQ
Is AP Computer Science A hard?
It's moderately hard, with a specific difficulty profile: the concepts are accessible, but Java demands precision — a missing semicolon or an off-by-one loop bound breaks everything. Students with no coding background can absolutely earn a 5; what predicts success is regular hands-on practice writing and tracing code, not prior experience. The free-response section is where unprepared students lose points, because reading code fluently is much easier than writing it under time pressure.
Do I need to know Java before taking AP Computer Science A?
No. The course teaches Java from zero, starting with variables and arithmetic and building up to full class design. The only real prerequisite is comfort with basic algebra. That said, spending a few weeks over the summer with a free Java tutorial gives you a genuine head start, since early fluency with syntax frees you to focus on the algorithmic thinking the exam actually rewards.
What is the difference between AP Computer Science A and AP Computer Science Principles?
CSA is a programming depth course: one language (Java), serious code writing, equivalent to a college CS1 class. Principles is a breadth course covering the internet, data, cybersecurity, and computing's social impact, with lighter programming in any language plus a through-course performance task. Colleges generally treat CSA as the stronger signal for CS majors. Many students take Principles first and then CSA, but neither course requires the other.
Is recursion on the AP Computer Science A exam?
Not anymore. The revised course framework that took effect in fall 2025 removed recursion, inheritance, and polymorphism from the exam, consolidating the course into four assessed units: Using Objects and Methods, Selection and Iteration, Class Creation, and Data Collections. If you're using older prep books or released exams, skip the recursion questions for exam prep — but the topic is still worth learning before college CS courses, where it appears immediately.
What percent do you need to get a 5 on AP Computer Science A?
The College Board does not publish a fixed cutoff, and the composite score needed for each 1-5 score varies slightly from year to year with exam difficulty. You do not need a perfect paper: a strong majority of multiple-choice questions correct, plus most rubric points across the four FRQs, has historically been 5 territory. Aim to bank the easy rubric points on every FRQ rather than perfecting just one question.
Ready to master AP Computer Science A?
Get all 6 unit videos, note packets, 120 quiz questions, 5 full-length practice exams, and a 24/7 Socratic AI tutor — $7.99/month with a 3-day free trial.