AP Computer Science A: The Complete Guide to the Four-Unit Course, the Exam & How to Prepare

A disclosure before anything else. Texas CBE™ is an independent preparation platform. We are not affiliated with, endorsed by, or connected to the College Board in any way. AP® is a trademark registered by the College Board, used here only to identify the exam that students we work with are preparing for. We do not reproduce College Board questions, scoring rubrics, or Course and Exam Description text — everything described below is either a verifiable fact about the exam or our own independently authored material.

AP Computer Science A is a Java programming course. Not a survey of computing, not a “how computers work” course — a course in which you write Java code by hand, with no compiler to tell you where the semicolon went. That distinction matters more than almost anything else in this guide, because a large share of students land in this class because a parent or counsellor said “take a CS class,” and it is very often their first programming course of any kind.

The course was also restructured. The Course and Exam Description effective Fall 2025 replaced the previous ten-unit framework with four units. Any guide, tutor, or study book still walking you through “Unit 7: ArrayList” and “Unit 10: Recursion” is describing a retired course structure. This guide is written against the current four-unit framework.

The exam at a glance

College Board publishes the following format for AP Computer Science A. The exam runs three hours and is administered digitally through the Bluebook testing app, with responses submitted automatically at the end.

• Section I — Multiple choice: 42 questions, 1 hour 30 minutes, 55% of the exam score.
• Section II — Free response: 4 questions, 1 hour 30 minutes, 45% of the exam score.

Two corrections to things you will still read elsewhere. First, Section I is 42 questions. A 40-question figure circulates widely in older prep material and is no longer what College Board publishes. Second, no calculator is permitted. College Board’s calculator policy states that calculators are not allowed for any AP Exams other than those specifically listed, including Computer Science A and Computer Science Principles, unless a student has an approved accommodation for use of a four-function calculator. Students sometimes arrive expecting one because other AP STEM exams allow them. They do not need one, and they will not get one.

The Java Quick Reference is provided to students during both the multiple-choice and free-response sections. Per the appendix of the current Course and Exam Description, it covers the String, Integer, Double, Math, ArrayList, File, Scanner, and Object classes. Students should practise with it available rather than memorising around it, because knowing where a signature lives on that sheet is faster than recalling it under pressure.

On timing: the 2026 administration was held Friday, May 15, 2026, at 12 p.m. local time. College Board had not published the 2027 date at the time of writing, and the date shifts within May from year to year, so check College Board’s official exam-dates page for the next administration rather than assuming it repeats. A late-testing window exists, but it is not something a student elects — the school must approve a documented conflict or emergency, and alternate exam forms are used.

The four units, and what the percentages actually mean

Here is a precision point that most summaries get wrong. In the current Course and Exam Description, this column is labelled as an approximate weighting for the multiple-choice section, and the surrounding text is explicit that these are the units’ weightings on the multiple-choice section of the exam. They are not percentages of the whole exam, and you should not plan revision as if they were, because Section II is a separate 45%.

• Unit 1 — Using Objects and Methods: approximately 15–25% of the multiple-choice section.
• Unit 2 — Selection and Iteration: approximately 25–35%.
• Unit 3 — Class Creation: approximately 10–18%.
• Unit 4 — Data Collections: approximately 30–40%.

Unit 4 is the centre of gravity. At roughly 30–40% of the multiple-choice section it is the heaviest unit, and it also maps onto the free-response questions students have historically performed worst on. Data Collections covers arrays, ArrayList, 2D arrays, traversals, searching, and sorting — and it is where recursion now lives.

Recursion deserves its own note, because its status changed. It is no longer a standalone unit; it appears as topics inside Unit 4 covering recursion and recursive searching. More importantly, the current Course and Exam Description carries an exclusion statement to the effect that writing recursive code is outside the scope of the course and exam. Practically: students are asked to trace recursive calls and determine output or behaviour. They are not asked to author a recursive method from scratch. That reshapes how much time is worth spending on it — enough to trace confidently, not enough to master recursive design.

Unit 3, Class Creation, carries the lowest multiple-choice weighting of the four. Do not read that as “low priority.” Class Design is one of the four free-response questions, so Unit 3 is under-weighted in Section I and over-weighted in Section II. That asymmetry is exactly the sort of thing that catches students who revise by percentage alone.

Section II: the four free-response questions

College Board publishes the four free-response tasks in a fixed order:

• Question 1 — Methods and Control Structures. Writing code that creates objects and calls methods.
• Question 2 — Class Design. Defining a new type by writing a class.
• Question 3 — Data Analysis with ArrayList. Manipulating list structures.
• Question 4 — 2D Array. Creating, traversing, and manipulating elements of a two-dimensional array.

A deliberate omission here: we are not going to publish a per-question point breakdown for the current exam. Point allocations circulate confidently on prep sites and we could not confirm a current one from College Board’s own published materials, so we would rather say nothing than repeat a plausible-sounding number. What we can state from the published 2025 Chief Reader Report is that on the 2025 exam each free-response question carried nine scoring points. If you are practising with older released free-response questions — and you should, the skills transfer — treat their scoring guidelines as a guide to what readers reward, not as a converter for a current raw score. Check the most recent official released materials for anything point-related.

Ninety minutes for four questions works out to roughly 22 minutes each, but that is an average, not a plan. Q1 and Q3 tend to be the more contained tasks; Q2 and Q4 are where time disappears. Practise with a clock from the start, and hold five minutes back at the end, rather than discovering the pacing problem in May.

The specific failure mode: a blank editor on Q2

Here is the pattern that costs first-time programmers the most points, stated plainly.

A student takes the class, follows along all year, and can read Java perfectly well. Given a method with a loop in it, they can tell you what it prints. Given four multiple-choice options, they can eliminate three. What they have never done — not once — is produce an entire class from a written specification, starting from an empty file. In most classrooms the teacher supplies the class skeleton and the student fills in the method bodies. That is a completely different task from what the Class Design question asks.

Q2 gives a scenario plus a specification, and requires the student to write the class header, the private instance variables, the constructor or constructors, and the method implementations — the whole artifact. A student who has only ever completed methods inside someone else’s class stalls at the first line. Not because they lack understanding, but because they have never rehearsed the motion. A full free-response question sits behind a skill that is entirely drillable and frequently never drilled.

The remedy is unglamorous and it works: write complete classes from written specs, repeatedly, from a blank editor, until the opening four lines are automatic. Class header. Private instance variables. Constructor assigning parameters to fields. Then the specified methods. If a student can produce that scaffold in ninety seconds without thinking, Q2 stops being a wall and becomes a fill-in exercise.

What the scoring data actually says

The most recently published score distribution at the time of writing is from the May 2025 exam. College Board’s published percentages were: 5 — 25.6%; 4 — 21.8%; 3 — 19.8%; 2 — 10.9%; 1 — 22.0%. That puts roughly 67% at a 3 or higher, from a cohort of about 94,000 students, with a global mean of 3.18 reported in the Chief Reader Report for that year.

Two caveats, and they are load-bearing. First, that distribution reflects an exam administered under the previous framework. The Chief Reader Report for 2025 states directly that the new Course and Exam Description takes effect for courses taught in 2025–26 and for exams administered in May 2026. So 2025 is the newest complete data that exists, but it is not a distribution for the course being taught now. Treat it as a description of the student population and the difficulty band, not as a forecast — and certainly not as a prediction of any individual student’s result.

Second — and this is the single most useful observation for a parent — look at the shape. Roughly a quarter of students earned a 5. Roughly a quarter earned a 1. Nearly a quarter at the top and nearly a quarter at the bottom, with a comparatively thin middle. This exam does not produce a gentle bell curve. It sorts. Students who genuinely learned to write code tend to do very well; students who learned to recognise code without writing it tend to fall through, and there is not much of a soft landing between the two outcomes. That is the argument for intervening early rather than waiting for a March practice test to reveal the problem.

What actually costs points, from the readers themselves

College Board publishes a Chief Reader Report each year describing what students actually did wrong. The 2025 report is specific, and its error patterns transfer even though its scoring structure may not. Reported mean scores by question that year, out of nine, were 4.54 on Q1, 5.24 on Q2, 4.12 on Q3, and 3.96 on Q4. The array/ArrayList and 2D-array questions were the weakest — which is Unit 4, the heaviest unit in the current framework. That alignment is not a coincidence, and it tells you where practice hours belong.

The error patterns the report describes, in our own words:

• Class-design mechanics. Some responses omitted required lines entirely, or mistakenly merged the class header with the constructor header by adding parentheses or parameters to the class header. Omitting private on instance variables cost the instance-variable point, because keeping attributes internal to the class is a course requirement and a public field does not satisfy it.
• Casting and range errors with random values. On the 2D-array question, most responses called Math.random() correctly but many could not transform the result into an integer in the required range. Casting before multiplying — applying (int) to the raw random value and then multiplying — collapses the result to zero every time. Others scaled by the wrong amount or failed to shift the range. Drill the general pattern until the parentheses are automatic.
• Missing the self-pairing guard. This was the single hardest scoring point across the whole 2025 free-response section. The task required not pairing an element with itself; the large majority of responses did not guard against it at all, and among those that tried, most excluded the entire row and column instead of just the one element. The correct shape is a condition that excludes only the single element — if (r != row || c != col) — not a condition joined with a logical AND.
• String off-by-one errors. substring calls reaching one character too far, or computing the wrong index when trimming from the start or the end. Reread the two-argument form until the exclusive upper bound is instinct.
• Returning too early. On the 2D-array question, a common algorithmic error was returning false after the first pair checked failed the condition, rather than after all pairs had been considered — or neglecting to return at all at the end.

One more, and it is a digital-exam artifact worth telling every student. The report notes that an unexpected number of submitted responses arrived with little or no indentation. Java does not require indentation, and an unindented but correct response can still earn full credit. But when a brace is missing, unindented code is very hard to read — and the student cannot find their own error. Practise indenting inside the Bluebook editor so it is habitual under time pressure. It costs seconds and saves recoveries.

AP Computer Science A vs AP Computer Science Principles

These are two different exams testing different skills. They are not tiers of one course, and families routinely pick the wrong one.

• Nature. CS A is a programming course, specific to Java. CSP covers broad computing concepts and is not tied to one language.
• Section I. CS A: 42 multiple-choice questions, 90 minutes, 55%. CSP: 70 multiple-choice questions, 120 minutes, 70%.
• Section II. CS A: four free-response questions written on exam day, 90 minutes, 45%. CSP: a through-course Create performance task plus an end-of-course written response section, together 30%.
• Through-course work. CS A has none. CSP students get 9 hours of in-class time to build a program, record a demonstration video, and develop a Personalized Project Reference.
• Exam-day writing. CS A: write Java from a specification, cold. CSP: written responses about the student’s own project, with their reference materials available.

The practical distinction for a family choosing between them: CSP spreads part of the work across the year into a project the student can revise and improve before submitting, and exam-day writing is about their own familiar code. In CS A, 45% is won or lost in ninety minutes of writing Java by hand, cold. A student who has never programmed and whose parent said “take a CS class” should understand which of those two situations they are signing up for.

Neither is inherently the better choice. CSP suits a student exploring whether computing interests them, or one whose schedule cannot absorb a heavy nightly problem load. CS A suits a student who intends to keep programming. Two honest cautions: college credit and placement policies for both exams vary enormously by institution and change over time, so check the specific colleges on your list directly rather than assuming anything; and taking CSP first is a reasonable on-ramp to CS A but is not a stated prerequisite for it.

Prerequisites, and who should actually take this

The current Course and Exam Description recommends that a student entering AP Computer Science A has successfully completed a first-year high school algebra course, with a solid foundation in basic linear functions, composition of functions, and problem-solving strategies requiring multiple approaches. It also expects students to be able to use a Cartesian coordinate system to represent points on a plane.

Note what that does and does not say. It does not assert that prior programming experience is unnecessary, and we are not going to make claims on College Board’s behalf about that. What the reader reports suggest is narrower and more useful: a student with no prior programming experience can absolutely succeed, but only if they spend the year writing code rather than reading it.

The function prerequisite is more relevant than it looks. A student comfortable with the idea that a function takes inputs, does something, and returns an output already has the mental model that methods require. A student for whom that is still shaky in algebra will find methods, parameters, and return values genuinely disorienting for the first two months.

Exam fees, including Texas assistance

Per College Board’s published Texas state assistance page, the standard fee is $99 per exam, or $90 if the school forgoes its $9 rebate. For students who meet College Board’s fee-reduction criteria, the reduction is $37 per exam.

Texas goes further. The State of Texas contributes an additional $27 per exam for eligible public school students, bringing the final cost for a fee-reduced student to $26. That is a meaningful reduction and it is under-claimed. Three things to know: enrollment in a CEP or Title I school or district does not confer automatic eligibility — students are verified individually; the state contribution is for public school students, with homeschooled students testing at public schools excluded from the state subsidy even where they qualify for the College Board reduction; and there is a hard coordinator deadline each year for marking fee-reduction status in AP Registration and Ordering — for the 2026 administration it was April 30, 2026. That makes this an autumn conversation with the AP coordinator, not an April one.

A realistic preparation timeline

September through November. Units 1 and 2. The goal is not speed, it is fluency in the basics: objects and method calls, conditionals, loops, and the ability to trace code accurately by hand. Trace on paper. A student who cannot predict what a nested loop prints will not survive Unit 4.

December through February. Unit 3, Class Creation, and the start of Unit 4. This is when the class-writing drill begins — complete classes from written specs, from a blank file, at least weekly. If a student reaches March having never written a class unaided, the March-to-May window is uncomfortably tight for fixing it.

March. Unit 4 in earnest: ArrayList, 2D arrays, traversals, searching, sorting, and enough recursion tracing to handle multiple-choice items. Start full free-response sets under time. Score them honestly against model answers — generously scored practice is worse than no practice.

April. Full timed sections. At least two complete 90-minute multiple-choice sections and three or four full free-response sets. Work inside a plain editor without autocomplete, syntax highlighting, or a compiler, because that is the exam condition. Rehearse the Java Quick Reference until finding a signature takes seconds.

The last two weeks. No new material. Re-attempt the free-response questions previously scored lowest. Review the specific error list above — casting order, loop bounds, the self-pairing guard, private on instance variables, substring bounds, returning too early — and confirm each one is no longer a live risk. Sleep more than you study.

What to do on Monday

Concretely, if you are a student in or entering this course:

• Open a blank file and write a complete class from a written specification, unaided. If you cannot, that is your entire priority for the next month.
• Read the Java Quick Reference end to end once so you know what is on it.
• Write out the general cast-and-shift pattern for a random integer in a range until the parenthesis placement is muscle memory.
• Do ten hand-traces of nested loops and recursive calls on paper, no compiler.
• Ask your AP coordinator, this autumn, whether you qualify for fee reduction — in Texas that can bring a $99 exam down to $26.
• If you are still choosing between CS A and CSP, decide based on how you want the work distributed across the year, not on which sounds more impressive.

How Texas CBE™ fits

Our AP Computer Science A preparation is built against the current four-unit framework, with practice organised by unit so a student can work on Unit 4 specifically rather than grinding mixed review. There is a free quiz that requires no account — try it before deciding anything. The regular price is $39.99 per AP course for six months of access.

Two honest limitations. First, free response on our platform is self-scored against a model answer. We do not grade free response, and we will not pretend a machine score is a reader score. What we provide is the specification, the model answer, and the discipline of writing the code before you look. Second, we make no guarantee of any score or outcome, and we cannot tell you what any particular college will accept — credit and placement policies vary by institution and change, so check with the colleges directly.

Once more, because it matters: Texas CBE™ is independent and is not affiliated with or endorsed by the College Board. We are not the official exam and we do not administer it. We do not reproduce College Board questions, scoring rubrics, or Course and Exam Description text. Everything on our platform is independently authored to match the published exam format and skills, and every figure in this guide is drawn from College Board’s own published materials, linked in the sources below.