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.
AP CSA is learnable if you treat it as a skills exam rather than a memorization exam. The concepts are concrete: loops, conditionals, arrays, ArrayLists, classes, and object references. Students who practice tracing code by hand and writing methods from specs consistently perform better than those who only read notes.
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.
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.
Can you trace a 10-line Java method with a loop and a conditional and state the exact return value without running it?
| 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.
Can you write a complete Java class with private fields, a constructor, and two methods in under 22 minutes given only a written specification?
| 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.
Do you know which FRQ is worth the fewest points and how that should affect your time allocation?
| 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.
Pick any 10-15 line Java method with a loop and a conditional. Trace it line by line on paper, tracking variable values at each step. This is the single most tested skill in Section I.
Practice FRQ 2 by reading a written spec and writing the class header, private fields, constructor, and methods without looking at examples. Check that your constructor initializes all instance variables and that your methods match the return types in the spec.
Write methods that iterate an ArrayList, check a condition on each element, and either collect results into a new list or return a calculated value. This is the core pattern for FRQ 3 every year.
Write methods that use nested for loops to traverse a 2D array by row, by column, and diagonally. Know how to access grid[r][c] and how to get the number of rows and columns from a 2D array.
Look at the official Java Quick Reference sheet before the exam so you know exactly what is on it. You do not need to memorize String, Math, or ArrayList method signatures, but you need to know the sheet exists and how to use it quickly.
Do at least one timed FRQ session where you write all four responses in 90 minutes. Knowing how 22 minutes feels for FRQ 2 is different from knowing it intellectually.
After a practice session, use the AP CSA score calculator to estimate your composite score. This helps you identify whether your MCQ accuracy or FRQ point totals need more attention in the final days before the exam.
Read through the topic guides for each FRQ type and the MCQ overview before doing any practice. Knowing that FRQ 3 is always ArrayList and FRQ 4 is always 2D array changes how you allocate study time.
Spend focused sessions tracing Java methods by hand. Cover loops with counters, while loops with changing conditions, and methods that call other methods. This directly targets the 37-53% of MCQ questions focused on code analysis.
Use the topic guides for FRQ 1 through FRQ 4 to understand the rubric for each question type, then write at least one response for each type under timed conditions. FRQ 2 (class design) and FRQ 4 (2D array) tend to take the most practice to feel comfortable.
At least once before the exam, sit down for a full 3-hour session: 90 minutes of MCQ followed by 90 minutes of all four FRQs. Use the score calculator afterward to see where you stand.
Use your score calculator results and your timed FRQ attempts to identify which question type or topic costs you the most points. Spend the final week doing focused practice on that area rather than reviewing everything equally.
Open the individual guides for AP Computer Science A Exam when you want a closer review of one topic.
Use AP-style practice after you review the notes so you can check what you understand.
Practice free-response reasoning and compare your answer with scoring guidance.
Watch past review streams filtered to AP Computer Science A Exam when you want a video walkthrough.
Open the Fiveable one-page unit review, then explore visual cheatsheets for a quick refresher.
Estimate your broader AP score goal after you review the course and exam format.
Print the cheatsheet bundle ($14) or full-length exam ($12) for this subject. Yours to keep, no subscription needed.
get printablesThe 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.