January 1, 1970

AP Computer Science A Study Guide: How to Score a 4 or 5

AP Computer Science A exam structure showing multiple choice and free response sections with time and score breakdowns

One in four AP Computer Science A students scored a 1 in 2025. Not a 2 — a 1, the floor. That's 23% of the 93,906 students who sat for the exam walking away with the minimum possible score on a course most of them chose voluntarily. College Board's own data confirms it.

The frustrating part: AP CSA is not an especially unpredictable exam. The four FRQ question types have been the same for years. The unit weights are published. The Java Quick Reference is handed to you during the test. What sends students to a 1 isn't bad luck — it's showing up underprepared for the specific skills the exam actually measures.

Here's what those skills are, and how to build them.

What the AP CSA Exam Actually Looks Like

Section I is 42 multiple-choice questions in 90 minutes, worth 55% of your composite score. No penalty for wrong answers, so guess on every question you don't finish. Leaving one blank is a free miss.

Section II is 4 free-response questions in another 90 minutes, worth 45%. Each FRQ is graded on a 9-point rubric by trained AP readers, giving you a maximum raw FRQ score of 36 points.

Composite = (MCQ Correct ÷ 42) × 55 + (FRQ Points ÷ 36) × 45

To earn a 5, you need roughly 78 composite points. That works out to about 35 correct MCQ answers (83%) and 26 FRQ points out of 36 (72%). A 4 sits around 65 composite — approximately 30 correct MCQs and 21 FRQ points. Both are reachable with focused prep.

One structural change that matters for 2026: the exam is fully digital, delivered through College Board's Bluebook platform. The Java Quick Reference (a list of accessible library method signatures) is built directly into the app. You don't need to memorize Collections.sort(), Math.pow(), or ArrayList method parameters — Bluebook gives them to you. That's genuinely useful, and it shifts your prep priorities away from rote memorization toward applied reasoning.

How the Four Units Are Weighted

The 2025-26 curriculum restructured around four units instead of the old ten-unit model. The weights are published, so use them.

Unit	Topic	Exam Weight
Unit 1	Using Objects & Methods	15–25%
Unit 2	Selection & Iteration	25–35%
Unit 3	Class Creation	10–18%
Unit 4	Data Collections	30–40%

Units 2 and 4 together represent up to 75% of your exam score. That's not a suggestion to focus there — it's math.

Unit 4 (Data Collections) is the highest single-unit weight, and it's also where most students lose the most ground. Arrays, ArrayLists, and 2D arrays don't just show up as isolated MCQ questions — they're embedded in nearly every complex reasoning problem in the test. And two of the four FRQ types are dedicated entirely to ArrayList operations and 2D array manipulation. More on that in the next section.

Unit 3 (Class Creation) gets the smallest slice (10–18%), but don't blow it off. It covers inheritance and polymorphism, which show up in one of the four FRQs and appear regularly in MCQ scenarios involving method overriding. One misunderstood concept about dynamic dispatch can cost you 3–4 points.

Cracking the Multiple Choice Section

The most important MCQ skill isn't Java knowledge. It's code tracing: reading a block of code and working out exactly what it does, line by line, without running it in a compiler.

Most MCQ questions follow one of these patterns:

A loop runs — what does the output look like, or what is a variable's final value?
A class hierarchy is shown — which version of an overridden method gets called?
Two strings are compared — which comparison operator gives the correct result?
A method receives an argument — what changes inside the method, and what stays the same?

That last one (parameter passing) trips up a lot of students. Java passes primitive types by value, meaning changes inside the method don't affect the original variable. Objects are passed by reference — changes to the object's state do persist, but reassigning the reference inside the method doesn't affect the caller. This distinction appears on the exam more often than students expect.

After the 2025 exam, College Board's AP Programs head Trevor Packer noted that students performed well on primitive types, Boolean expressions, and if statements — with 44% of test-takers earning 7 or 8 of the 8 points on those question clusters. Where scores dropped was loops, collections, and inheritance. Which is precisely Units 2 and 4.

The most efficient MCQ prep is timed code-tracing practice. Pick 10 MCQ problems, set a stopwatch, and work through each one step by step. Review every wrong answer and figure out exactly where your reasoning diverged from the correct answer. Thirty minutes of this three times a week builds the skill faster than any flashcard set.

The Four FRQ Types and How to Approach Each

Every AP CSA exam uses the same four FRQ categories. This has been true for years. Knowing what to expect for each type is half the preparation.

FRQ Type	What You Write
Methods and Control Structures	2 methods, or 1 constructor + 1 method
Class Design	A full class: fields, constructor, and methods
ArrayList Data Analysis	1 method that reads or modifies an ArrayList
2D Array	1 method that traverses or manipulates a 2D array

Partial credit is the FRQ's most underutilized feature. The rubric awards points for individual correct components — not just correct complete solutions. A method header with the right return type earns a point. A correct loop structure earns a point. A valid return statement earns a point. Even an answer that gets the core logic wrong can score 5 out of 9 if the surrounding structure is right.

Four practices that pay off across all FRQ types:

Read the method signature before writing anything. It tells you the return type, parameter types, and expected behavior. Returning the wrong type is an automatic zero for that component, and it's a trivially avoidable error.
Write the skeleton first. Method header, empty body, return statement. Then fill in logic. You'll capture header points even if you run out of time before finishing the implementation.
For ArrayLists: never remove elements while iterating forward with a standard index counter. When you remove the element at index i, the next element slides to index i. Your counter then skips it entirely. Iterate backward, or decrement your index variable after each removal.
For 2D arrays: name your indices row and col instead of i and j. It sounds trivial. But students who transposed row and column in a nested loop — a single-character mistake — lost the traversal points. The labeling habit prevents it.

Mistakes That Separate a 3 From a 4

These aren't obscure gotchas. They're the errors that appear on scoring rubrics year after year, because students make them year after year.

Using == to compare Strings. Two String variables with the same text content are not necessarily the same object in memory. "hello" == "hello" can evaluate to false. The operator == checks reference equality; .equals() checks value equality. Every string comparison in your FRQ code should use .equals(). This also shows up in MCQ as a conceptual trap.

Off-by-one errors in loop bounds. Array indices go from 0 to array.length - 1. A loop condition of i <= array.length accesses a nonexistent index and throws ArrayIndexOutOfBoundsException. The exam tests this both conceptually (MCQ asks what a slightly wrong loop outputs) and practically (FRQ rubrics penalize incorrect loop bounds).

Leaving FRQ answers blank. An empty response earns exactly 0 points. A partially correct response with a valid method signature, a reasonable loop attempt, and an approximate return statement might earn 3 or 4 points. Those points move you from a 3 to a 4. Always write something.

Ignoring preconditions. When an FRQ problem says "precondition: the list is not null and contains at least one element," College Board is explicitly telling you not to handle those edge cases. Students who write extra null checks and boundary guards introduce bugs, waste time, and sometimes break their own solutions. Trust the stated preconditions.

Getting dynamic dispatch wrong. When a parent-class variable holds a child-class object and you call an overridden method, the child's version runs. Every time. This is how Java works, it's tested in MCQ regularly, and it's one of those concepts that students think they understand until they see it in a slightly unfamiliar form.

A Realistic Study Plan

The structure below assumes you're working from content coverage first, then practice. Adjust based on how much you already know.

If you have 6–8 weeks:

Weeks 1–2: Units 1 and 2. Objects, methods, conditionals, loops. Make sure you can trace nested loops by hand and write loop-based solutions from scratch without a compiler.
Weeks 3–4: Unit 3. Class design, inheritance, method overriding, polymorphism. Focus on constructor chaining and how super works.
Weeks 5–6: Unit 4 only. Arrays, ArrayLists, 2D arrays. Write at least 15 standalone methods using these structures under timed conditions.
Week 7: Two full practice exams, timed (42 MCQ + 4 FRQ each). Review every wrong MCQ answer and understand why.
Week 8: FRQ-only. Write past FRQs by hand, then compare line-by-line to the published College Board scoring guidelines.

If you have 2–3 weeks:

Drop the balanced-coverage approach entirely. Units 2 and 4, FRQ types 3 and 4 (ArrayList and 2D Array), and the official rubrics for 5–7 recent FRQ sets. That's it.

The best free study resource available is College Board's own past FRQ archive, with solutions and rubrics going back to 2004. Reading rubrics teaches you more about earning partial credit than any prep book, because you see exactly which components graders reward and which errors lose points. Albert.io's unit-by-unit MCQ practice is worth your time too, particularly for the tricky OOP and iteration questions.

My honest take: most prep guides tell you to cover all four units equally. With two weeks left, you physically cannot do that and go deep enough on any of them. Units 2 and 4 are where students lose the most points — and where focused practice returns the most points back. That's where the time goes.

Bottom Line

Score math: 35+ correct MCQ answers and 26+ FRQ points gets you to a 5. A 4 requires roughly 30 MCQ and 21 FRQ points.
Unit 4 is the highest-leverage study area. Data Collections drives 30–40% of the exam and anchors two of the four FRQ types.
Write something for every FRQ. Correct method signatures, loop structures, and return types earn points even when the full logic is wrong.
Stop using == to compare Strings. It's the most reliably tested mistake on the exam, year after year.
The Java Quick Reference is in Bluebook. Use that bandwidth on code tracing and FRQ practice instead of memorizing method signatures.

Frequently Asked Questions

How hard is it to get a 5 on AP Computer Science A?

In 2025, 25% of test-takers scored a 5 — a higher rate than many AP STEM courses. Getting there consistently requires accurate code-tracing under time pressure and clean execution on at least 3 of the 4 FRQ types. Students with no prior programming experience can absolutely reach a 5, but they need to write a lot of actual Java during prep — not just read about it.

Do I need to memorize Java syntax for the 2026 exam?

Not the library methods. The Java Quick Reference is built into Bluebook and covers Math, String, ArrayList, and array method signatures. You do need to know core Java syntax — if/else, for loops, while loops, class declarations, and how to define instance variables — because those aren't provided and show up constantly on both MCQ and FRQ.

What's the difference between AP Computer Science A and AP Computer Science Principles?

AP CSA is Java-based and focuses on object-oriented programming, algorithms, and data structures. AP CSP covers broader computing concepts (networks, data representation, cybersecurity) and is language-flexible. CSA is harder and more technical. For students planning to major in CS or engineering, CSA carries more weight on college applications — most admissions offices treat the two as separate, non-interchangeable courses.

Can I still score well on FRQs if my code isn't perfect?

Yes. The rubric scores individual components independently: correct method header, correct loop structure, correct return, correct use of a provided method. A solution that gets the overall logic slightly wrong but has every structural element right might earn 6 or 7 out of 9. Attempting every part of every FRQ and getting the structural pieces right is a better strategy than writing one perfect response and leaving another blank.

What if I only have one week left before the exam?

Prioritize in this order: (1) ArrayList iteration and removal — the most FRQ-tested topic; (2) 2D array nested loop traversal; (3) inheritance and method overriding for MCQ; (4) loop tracing for speed. Do three or four past FRQs under timed conditions and read the official rubric after each one. That feedback loop is more useful at this stage than any additional content review.

Is it a myth that AP CSA is mostly about memorizing Java keywords?

Yes. The most common misconception going into the exam is that it rewards students who've memorized the most vocabulary. It doesn't. AP CSA rewards students who can read and write working code under timed conditions. A student who can trace a 20-line loop in under two minutes will consistently outperform a student who memorized every keyword but never practiced actual code execution. Writing code during prep — not just reading it — is what builds the skill the exam actually tests.