AP Computer Science A Exam: Format & What’s on It

The essentials: the AP Computer Science A exam is a fully digital, ~3 hour exam with two sections. Section I (Multiple Choice): 42 questions, 1 hr 30 min, 55% — four answer choices, mostly individual questions, testing reading and analyzing Java code. Section II (Free Response): 4 questions, 1 hr 30 min, 45% — where you write actual Java code in the Bluebook editor. The four free-response questions are the same types every year: Q1 Methods & Control Structures, Q2 Class Design, Q3 Data Analysis with ArrayList, Q4 2D Array. The course uses Java and is organized into four units (recently redesigned from ten): Unit 1 Using Objects & Methods, Unit 2 Selection & Iteration, Unit 3 Class Creation, Unit 4 Data Collections — with Unit 4 (arrays, ArrayLists, 2D arrays) heaviest. You get the Java Quick Reference on screen. It’s roughly a first-semester college CS course, and its companion is AP Computer Science Principles (the broad, no-language course). Here’s the full breakdown.

What AP Computer Science A is

Before the format, a quick orientation to what this course actually is. A real Java programming class.

AP Computer Science A is a genuine programming course — essentially the equivalent of a first-semester college computer science class, taught in Java. Unlike AP Computer Science Principles (which is a broad, conceptual introduction to computing), CSA is focused and technical: you learn to write, analyze, test, and debug actual Java code. The course centers on object-oriented programming — classes, objects, and methods — along with problem solving, algorithm development, and core data structures (arrays, ArrayLists, 2D arrays). You’ll spend the year writing a lot of code, and the exam expects you to solve problems from scratch in Java, so real comfort with Java syntax and structure is essential. The College Board requires CSA courses to include at least 20 hours of hands-on lab time for programming practice, underscoring how practice-based the course is. CSA is best suited to students who are ready to learn serious programming — often those considering a computer science, software engineering, or STEM major, or who simply want to learn to code properly. It’s more demanding technically than CSP but rewards programming skill. A background in algebra and some basic programming familiarity helps, though it’s not strictly required. This hands-on, Java-based, code-writing focus is what shapes the exam. For the broad, beginner-friendly alternative, see the AP Computer Science Principles exam guide.

The AP Computer Science A exam format

Here’s the complete structure. Two equal-time sections, one reading code and one writing it.

The AP CSA exam is about 3 hours and has two sections of equal time. Section I is multiple choice: 42 questions in 1 hour and 30 minutes (90 minutes), worth 55% of your score, with four answer choices each. The questions are mostly individual (occasionally in small sets of 2) and test your ability to read and analyze Java code — determining output, tracing logic, finding errors, and reasoning about program behavior. Section II is free response: 4 questions in 1 hour and 30 minutes (90 minutes), worth 45% of your score, where you write actual Java code by hand (typed into the Bluebook code editor). The entire exam is fully digital in the Bluebook app — there’s no paper option — and all responses are submitted automatically at the end. A defining feature: the two sections are close in weight (55% and 45%), so both reading code (multiple choice) and writing code (free response) matter substantially. Note that this format reflects a recent redesign — the exam moved to fully digital and the structure was updated (the current version has 42 multiple-choice questions and 55/45 weighting). The Bluebook code editor provides syntax highlighting but no autocomplete, and the Java Quick Reference is available on screen throughout. The table lays out the structure.

Fully digital in Bluebook (no paper option). Four answer choices on MCQ. Java Quick Reference available on screen. Reflects the recent exam redesign.

The multiple-choice section in detail

Multiple choice is the larger piece at 55%, and it’s all about reading code. Trace, analyze, find errors.

The multiple-choice section is 55% of your score — the larger single piece — so it deserves serious attention. The specifics: 42 questions in 90 minutes (about 2.1 minutes per question), with four answer choices (A–D). The questions are mostly individual, though occasionally 1–2 sets appear (2 questions sharing a common scenario). What they test is fundamentally reading and reasoning about Java code: determining the output or result of a code segment given initial values, tracing program behavior, analyzing code for correctness, equivalence, and errors, and describing the conditions that lead to a result. In other words, you’re reading Java and predicting or evaluating what it does. This tests the same object-oriented and algorithmic concepts as the rest of the course — methods, control structures (conditionals and loops), classes, arrays, ArrayLists, and 2D arrays — but in a read-and-analyze format rather than a write-from-scratch one. The section is computer-scored, and (as with most AP exams) there’s no penalty for wrong answers, so you should answer every question. Because code-tracing is central, the best preparation is practicing reading Java carefully — following loops iteration by iteration, tracking variable values, and watching for off-by-one errors, boundary conditions, and subtle logic bugs. Strong code-reading skill translates directly into multiple-choice points. For how to drill this, see the practice guide.

The four free-response questions

Here’s a standout feature of CSA: the four free-response questions are the same types every single year. That predictability is a gift.

The free-response section (45% of your score) has a feature that makes it uniquely predictable: the four questions are the same types every single year, and have been for many years. All four require you to write Java code to meet given specifications. Question 1 — Methods and Control Structures: you’ll write two methods, or one constructor and one method, of a given class, using iterative or conditional statements and calls to other methods (including String methods). Question 2 — Class Design: you’ll design and implement a complete class from a specification (defining instance variables, a constructor, and methods), sometimes involving a second class. Question 3 — Data Analysis with ArrayList: you’ll write a method that uses, analyzes, and manipulates data in an ArrayList. Question 4 — 2D Array: you’ll write a method that creates, traverses, and manipulates a 2D array (typically with nested loops). This consistency is a huge advantage for preparation: because you know exactly what four question types you’ll face, you can practice each type deliberately until you’re fluent. A key strategy note: the questions differ in point value, so budget your time toward the higher-value questions and attempt every part (partial credit is awarded). You’ll also want to use the Java Quick Reference and write clean, syntactically correct code. The practice guide covers drilling each FRQ type.

The four units — and which matter most

The course was recently streamlined to four units, and one dominates. Here’s the map. Unit 4 (Data Collections) carries the most weight.

Following a recent redesign (which replaced the older ten-unit framework), the AP CSA course is now organized into four units, all tested but not equally weighted. They are: Unit 1 — Using Objects and Methods (about 15–25% of the multiple-choice questions; the foundation — objects, methods, and basic types); Unit 2 — Selection and Iteration (about 25–35%; conditionals and loops, the core of program logic); Unit 3 — Class Creation (about 10–18%; writing your own classes); and Unit 4 — Data Collections (about 30–40%; arrays, ArrayLists, and 2D arrays). The weighting is uneven and worth knowing: Unit 4 (Data Collections) carries the most weight — so expect the most questions on arrays, ArrayLists, and 2D arrays — and it maps directly to two of the four free-response questions (Q3 ArrayList and Q4 2D Array). Unit 2 (Selection and Iteration) is the second most weighted. The practical takeaway: give Unit 4 the most study time (it’s both the heaviest on multiple choice and half the free-response section), then Unit 2, while keeping a solid grasp of Units 1 and 3. All four units appear in both sections, so a balanced review with extra Unit 4 focus is ideal. Always confirm current weightings in the official Course and Exam Description, since the course was recently updated. The table shows the breakdown.

The Java Quick Reference

One helpful resource is provided on exam day: the Java Quick Reference. Knowing how to use it matters.

A useful thing to know: on the AP CSA exam, you’re given the Java Quick Reference — a document listing the commonly used methods from the Java library that may appear on the exam. It’s available on screen in the Bluebook app throughout the free-response section (and it’s also printable, so schools can provide a paper copy). What it does: it lists the accessible methods (for classes like String, Math, ArrayList, Object, and others) with their signatures and descriptions, so you don’t have to memorize exact method names and parameters. What it doesn’t do: it won’t write code for you or cover Java syntax (loops, conditionals, class structure) — you still need to know how to write correct Java. The practical value is significant: knowing exactly which methods are provided (and which you must remember on your own) is one of the highest-leverage things you can do before exam day. A smart move is to keep the Java Quick Reference open whenever you practice free-response questions, so you’re completely familiar with what’s available and can use it quickly under time pressure. One caution from the exam instructions: writing significant code that could be replaced by a provided library method won’t earn full credit, so knowing the reference helps you write efficient, full-credit solutions. Familiarity with this reference is a real, easy advantage. The practice guide covers using it well.

How the AP CSA exam is scored

Understanding scoring shows where your points come from. The two sections are close in weight.

Scoring combines your two sections into a final AP score from 1 to 5. On the multiple-choice section (55%), you earn one point per correct answer with no penalty for wrong ones — so answer every question. On the free-response section (45%), your four Java coding responses are scored by trained readers on detailed rubrics, awarding points for correct code components — and importantly, partial credit is awarded, so you should write something for every part, even if you can’t complete a whole question. Each free-response question has a different maximum point value, which is why budgeting time toward the higher-value questions matters. Your weighted multiple-choice and free-response points combine into a composite, which the College Board converts to the 1–5 scale using its annual standard-setting process (so cut points shift slightly year to year). The strategic implications follow from the near-even 55/45 split: both sections matter substantially, so you can’t neglect either reading code (MCQ) or writing code (FRQ) — balanced preparation is essential. Because the free-response section awards partial credit, attempting every part of every FRQ is one of the most reliable ways to bank points. Two notes on the numbers: the College Board doesn’t publish a fixed raw-to-score table (it’s re-set each year), and colleges generally look for a 4 or 5 (though some grant credit for a 3). To translate your section performance into a projected 1–5 and set a target, use the AP score calculator, and for what each score means, see what a good AP score is.

AP Computer Science A vs. AP Computer Science Principles

Since the two AP computer science courses are easily confused, here’s the distinction. Java programming vs. broad concepts.

AP Computer Science A and AP Computer Science Principles are both introductory computing courses, but they’re quite different. AP CSA is a focused programming course taught in Java — essentially a first college programming class — where you write actual Java code. Its exam is a traditional format: 42 multiple-choice questions (55%) and 4 free-response questions where you write Java (45%). AP CSP is a broad introduction to computing concepts — algorithms, data, the Internet, and the impact of computing — and it doesn’t require any specific programming language (its exam uses pseudocode). CSP’s exam combines a 70-question multiple-choice section (70%) with the through-course Create performance task (30%). In short: CSA is a deeper dive into programming (real Java coding), while CSP is conceptual and accessible (broad, less code-heavy). Which to take? CSA suits students ready to learn serious programming or considering a computer science or STEM major; CSP suits students wanting a broad, beginner-friendly introduction or newer to computing. On difficulty, they’re hard in different ways — CSP is more accessible to pass (no coding required), while CSA demands programming ability but has a higher rate of top scores among its more self-selected students. Many students take CSP first and CSA later, but they can be taken in either order or independently — neither is a prerequisite for the other. For the broad, conceptual course, see the AP Computer Science Principles exam guide.

How to prepare for the AP CSA exam

Knowing the format, here’s how to turn it into an effective study approach. Write code daily, drill the four FRQ types, focus on Unit 4.

The throughline: because AP CSA is a real programming exam that weights reading code (55%) and writing code (45%) almost evenly, effective preparation means writing Java constantly, drilling the four consistent free-response types, and mastering Unit 4. The predictable FRQ structure is a genuine gift — you know exactly what to practice. With steady, hands-on coding practice, CSA is very achievable, especially for students who enjoy programming. Set a target with the AP score calculator, then build your plan with the AP CSA practice guide and a realistic look at how hard AP CSA is.

AP Computer Science A exam: frequently asked questions