The AP Computer Science A exam tests your ability to write, trace, and reason about Java code across two sections: 42 multiple-choice questions and 4 free-response questions. Knowing the format, point values, and question types before exam day is one of the highest-leverage things you can do.
Use the topic guides below to review each question type in detail, then use the score calculator to estimate where you stand.
AP Computer Science A is fundamentally a code-reading and code-writing test. The multiple-choice section leans heavily on tracing existing code, while the free-response section asks you to write complete methods and classes from scratch given written specifications.
42 questions, 90 minutes, 4 answer choices each. Roughly half the questions ask you to trace or analyze existing code. The heaviest topic weighting falls on code analysis, making careful line-by-line tracing your most important skill here.
4 questions in 90 minutes, each with a fixed type: Methods and Control Structures (FRQ 1), Class Design (FRQ 2), Data Analysis with ArrayList (FRQ 3), and 2D Array (FRQ 4). Point values differ by question, totaling 25 FRQ points.
Precise Java syntax, correct loop and conditional logic, proper use of ArrayList traversal, and the ability to implement a class from a written specification. Partial credit is available on FRQs, so writing something syntactically close is always better than leaving a blank.
Each FRQ slot tests the same concept every year: FRQ 1 is always methods and control structures, FRQ 2 is always class design, FRQ 3 is always ArrayList manipulation, and FRQ 4 is always a 2D array traversal. That predictability means targeted practice on each question type is one of the most efficient ways to prepare.
42 questions, 90 minutes, 55% of your score. The dominant skill is code tracing. Use the Java Quick Reference for library method signatures and budget about 2 minutes per question. The topic guide covers question weighting, tracing strategy, and what to expect.
Worth 7 of 25 FRQ points. You write two methods using loops, conditionals, and calls to other class methods. Part A is 4 points and Part B is 3 points. The topic guide includes the rubric breakdown, a worked example, and timing strategy.
Worth 7 of 25 FRQ points. You write a complete Java class from a specification: class header, private instance variables, constructor, and methods. Budget 20-22 minutes. The topic guide walks through a worked class example and the point-by-point rubric.
Worth 5 of 25 FRQ points. You write one method that traverses an ArrayList, filters elements by condition, and returns a calculated result. The topic guide covers the scoring pattern, common filter-and-calculate patterns, and frequent errors.
Worth 6 of 25 FRQ points and the most predictable question on the exam. You write one method that traverses or manipulates a 2D array of objects. The topic guide covers row-major and column-major traversal patterns and a worked code example.
AP CSA is hard if Java is new to you, but the skills are concrete and learnable. The difficulty guide covers what makes the course challenging, what makes it manageable, and how to approach it if you have no prior programming experience.
The MCQ section is 42 questions in 90 minutes, which gives you about 2 minutes per question. Every question has 4 answer choices and no penalty for guessing. The exam is fully digital and the Java Quick Reference is available throughout. The heaviest emphasis is on analyzing code, meaning you will spend most of your time tracing what a given code segment does rather than recalling definitions.
| Skill | Approximate MCQ share |
|---|---|
| Analyzing existing code | 37-53% |
| Writing or completing code | remaining questions |
| Classes, objects, encapsulation | distributed across both |
The FRQ section is 4 questions in 90 minutes, which works out to roughly 20-22 minutes per question. Each question type is fixed from year to year, so you can practice each one specifically. FRQs are scored on rubrics that award points for specific code elements, meaning partial credit is real and meaningful. Writing a method with correct logic but a minor syntax error will still earn most of the points.
| FRQ | Type | Points |
|---|---|---|
| FRQ 1 | Methods and Control Structures | 7 |
| FRQ 2 | Class Design | 7 |
| FRQ 3 | Data Analysis with ArrayList | 5 |
| FRQ 4 | 2D Array | 6 |
Section I (MCQ) counts for 55% of your composite score and Section II (FRQ) counts for 45%. The 4 FRQs together are worth 25 raw points, and each question has a rubric that awards points for specific correct code elements. Because rubrics are element-based rather than holistic, a response that is mostly correct but has one bug can still earn the majority of available points. Never leave an FRQ blank.
| Section | Questions | Weight |
|---|---|---|
| Section I: MCQ | 42 questions | 55% |
| Section II: FRQ | 4 questions | 45% |
FRQ rubrics award points for individual correct elements. A method with the right signature and a correct loop structure earns points even if the logic has a bug. Writing something is almost always better than writing nothing.
FRQ 2 rubrics specifically check that your constructor sets all instance variables. Students who write the correct fields but forget to assign them in the constructor lose points that are easy to keep.
Using i <= array.length instead of i < array.length, or starting at index 1 instead of 0, are among the most common errors on both FRQ 3 and FRQ 4. Always check your loop bounds before moving on.
On FRQs, students sometimes write a method that prints output instead of returning a value, or returns the wrong type. Read the method signature in the specification carefully before writing any code.
Because roughly half of MCQ questions ask you to analyze code, guessing on logic questions without tracing is a significant score risk. Even a quick 30-second trace on paper is faster and more accurate than trying to reason about output in your head.
The ability to trace code in Section I and the ability to write correct code in Section II draw on the same underlying skill: understanding exactly what each line of Java does. Students who practice tracing tend to write cleaner FRQ responses because they can mentally simulate their own code before submitting.
FRQ 2 asks you to write a complete class, which means you need the method-writing and control-structure skills from FRQ 1 plus the ability to design fields and a constructor. Reviewing FRQ 1 concepts first makes FRQ 2 practice more productive.
Both the ArrayList question (FRQ 3) and the 2D array question (FRQ 4) require you to iterate through a data structure, check conditions on each element, and produce a result. Practicing one traversal pattern reinforces the other, so these two questions are efficient to study together.
Open the individual guides for AP Computer Science A Exam when you want a closer review of one topic.
browse guidesPractice free-response reasoning and compare your answer with scoring guidance.
practice FRQsWatch past review streams filtered to AP Computer Science A Exam when you want a video walkthrough.
open videosUse unit cheatsheets for a quick visual review after you work through the notes.
open cheatsheetsEstimate your broader AP score goal after you review the course and exam format.
open calculatorThe AP CSA progress checks in AP Classroom should align to the current four-unit course: objects and methods, selection and iteration, class creation, and data collections. Current AP CSA exam practice should emphasize Java code tracing, method writing, class design, arrays, ArrayLists, 2D arrays, recursion, searching, sorting, text-file input, and informal code analysis. Older progress checks or prep sets may include inheritance or polymorphism; treat those as retired topics unless your teacher assigns them separately.
AP CSA FRQs have four fixed types: Methods and Control Structures, Class Design, Data Analysis with `ArrayList`, and 2D Array. To practice, write out full Java methods or classes by hand, then check that your logic handles edge cases like empty arrays, null references when relevant, and off-by-one loop bounds. Rotate through method-writing, class-design, ArrayList, and 2D-array prompts so your practice matches the current exam.
For AP CSA practice questions, including MCQ and full practice tests, the best starting point is /ap-comp-sci-a/ap-computer-science-a-exam. There you'll find multiple-choice questions covering current topics like loops, recursion, class creation, arrays, ArrayLists, 2D arrays, and text files, plus FRQ-style prompts. Mixing MCQ drills with timed practice tests helps you build both accuracy and speed before exam day.
Start by making sure you can write and trace Java code for the four FRQ types: Methods and Control Structures, Class Design, Data Analysis with `ArrayList`, and 2D Array. Then work through MCQ sets that test objects, methods, Boolean logic, loops, arrays, ArrayLists, 2D arrays, text files, recursion, searching, sorting, and informal code analysis. Review your mistakes by actually rewriting the code, not just reading the solution. A solid weekly routine is one topic review session, one timed MCQ set, and one written FRQ.